* [Xenomai-core] [Patch 0/7] Posix skin user-space mutexes, second take. @ 2008-05-02 22:27 Gilles Chanteperdrix 2008-05-02 22:30 ` [Xenomai-core] [Patch 1/7] Support for non cached memory mappings Gilles Chanteperdrix 2008-05-03 19:18 ` [Xenomai-core] [Patch 0/7] Posix skin user-space mutexes, second take Gilles Chanteperdrix 0 siblings, 2 replies; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-02 22:27 UTC (permalink / raw) To: xenomai Hi, here comes a second attempt of implementing user-space mutexes for the posix skin. Only differences with the first implementation are explained in the following mails. Thanks in advance for your review. -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* [Xenomai-core] [Patch 1/7] Support for non cached memory mappings 2008-05-02 22:27 [Xenomai-core] [Patch 0/7] Posix skin user-space mutexes, second take Gilles Chanteperdrix @ 2008-05-02 22:30 ` Gilles Chanteperdrix 2008-05-02 22:32 ` [Xenomai-core] [Patch 2/7] Define XNARCH_SHARED_HEAP_FLAGS Gilles Chanteperdrix 2008-05-18 16:30 ` [Xenomai-core] [Patch 1/7] Support for non cached memory mappings Philippe Gerum 2008-05-03 19:18 ` [Xenomai-core] [Patch 0/7] Posix skin user-space mutexes, second take Gilles Chanteperdrix 1 sibling, 2 replies; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-02 22:30 UTC (permalink / raw) To: xenomai In addition to support for non cached memory mappings, this patch implements xnheap_init_mapped and xnheap_destroy_mapped in the !CONFIG_XENO_OPT_PERVASIVE case. This avoids a lot of #ifdefs for users of these functions without user-space support (posix skin shared memories, and the new semaphore heaps, heaps where is allocated the memory used for storing semaphores counters and mutexes owner fields). --- include/asm-generic/wrappers.h | 12 +++++--- include/native/heap.h | 1 include/nucleus/heap.h | 2 + ksrc/nucleus/heap.c | 55 +++++++++++++++++++++++++++++++++++------ ksrc/skins/native/heap.c | 8 +++++ 5 files changed, 66 insertions(+), 12 deletions(-) Index: include/native/heap.h =================================================================== --- include/native/heap.h (revision 3738) +++ include/native/heap.h (working copy) @@ -33,6 +33,7 @@ #define H_MAPPABLE 0x200 /* Memory is mappable to user-space. */ #define H_SINGLE 0x400 /* Manage as single-block area. */ #define H_SHARED (H_MAPPABLE|H_SINGLE) /* I.e. shared memory segment. */ +#define H_NONCACHED 0x800 /** Structure containing heap-information useful to users. * Index: include/asm-generic/wrappers.h =================================================================== --- include/asm-generic/wrappers.h (revision 3738) +++ include/asm-generic/wrappers.h (working copy) @@ -62,7 +62,7 @@ unsigned long __va_to_kva(unsigned long #define wrap_remap_vm_page(vma,from,to) ({ \ vma->vm_flags |= VM_RESERVED; \ - remap_page_range(from,virt_to_phys((void *)__va_to_kva(to)),PAGE_SIZE,PAGE_SHARED); \ + remap_page_range(from,virt_to_phys((void *)__va_to_kva(to)),PAGE_SIZE,vma->vm_page_prot); \ }) #define wrap_remap_io_page_range(vma,from,to,size,prot) ({ \ vma->vm_flags |= VM_RESERVED; \ @@ -223,7 +223,7 @@ unsigned long __va_to_kva(unsigned long * memory. Anyway, this legacy would only hit setups using pre-2.6.11 * kernel revisions. */ #define wrap_remap_vm_page(vma,from,to) \ - remap_pfn_range(vma,from,virt_to_phys((void *)__va_to_kva(to)) >> PAGE_SHIFT,PAGE_SHIFT,PAGE_SHARED) + remap_pfn_range(vma,from,virt_to_phys((void *)__va_to_kva(to)) >> PAGE_SHIFT,PAGE_SHIFT,vma->vm_page_prot) #define wrap_remap_io_page_range(vma,from,to,size,prot) ({ \ (vma)->vm_page_prot = pgprot_noncached((vma)->vm_page_prot); \ /* Sets VM_RESERVED | VM_IO | VM_PFNMAP on the vma. */ \ @@ -236,7 +236,7 @@ unsigned long __va_to_kva(unsigned long #else /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) */ #define wrap_remap_vm_page(vma,from,to) ({ \ vma->vm_flags |= VM_RESERVED; \ - remap_page_range(from,virt_to_phys((void *)__va_to_kva(to)),PAGE_SIZE,PAGE_SHARED); \ + remap_page_range(from,virt_to_phys((void *)__va_to_kva(to)),PAGE_SIZE,vma->vm_page_prot); \ }) #define wrap_remap_io_page_range(vma,from,to,size,prot) ({ \ vma->vm_flags |= VM_RESERVED; \ @@ -248,7 +248,11 @@ unsigned long __va_to_kva(unsigned long }) #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15) */ -#define wrap_switch_mm(prev,next,task) \ +#ifndef __GFP_BITS_SHIFT +#define __GFP_BITS_SHIFT 20 +#endif + +#define wrap_switch_mm(prev,next,task) \ switch_mm(prev,next,task) #define wrap_enter_lazy_tlb(mm,task) \ enter_lazy_tlb(mm,task) Index: include/nucleus/heap.h =================================================================== --- include/nucleus/heap.h (revision 3738) +++ include/nucleus/heap.h (working copy) @@ -57,6 +57,8 @@ #define XNHEAP_PCONT 1 #define XNHEAP_PLIST 2 +#define XNHEAP_GFP_NONCACHED (1 << __GFP_BITS_SHIFT) + typedef struct xnextent { xnholder_t link; Index: ksrc/skins/native/heap.c =================================================================== --- ksrc/skins/native/heap.c (revision 3738) +++ ksrc/skins/native/heap.c (working copy) @@ -205,6 +205,10 @@ static void __heap_flush_private(xnheap_ * operations with I/O devices. The physical address of the * heap can be obtained by a call to rt_heap_inquire(). * + * - H_NONCACHED causes the heap not to be cached. This is necessary on + * platforms such as ARM to share a heap between kernel and user-space. + * Note that this flag is not compatible with the H_DMA flag. + * * @return 0 is returned upon success. Otherwise: * * - -EEXIST is returned if the @a name is already in use by some @@ -260,7 +264,9 @@ int rt_heap_create(RT_HEAP *heap, const err = xnheap_init_mapped(&heap->heap_base, heapsize, - (mode & H_DMA) ? GFP_DMA : 0); + ((mode & H_DMA) ? GFP_DMA : 0) + | ((mode & H_NONCACHED) ? + XNHEAP_GFP_NONCACHED : 0)); if (err) return err; Index: ksrc/nucleus/heap.c =================================================================== --- ksrc/nucleus/heap.c (revision 3738) +++ ksrc/nucleus/heap.c (working copy) @@ -1097,9 +1097,13 @@ static int xnheap_mmap(struct file *file vaddr = (unsigned long)heap->archdep.heapbase; - if (!heap->archdep.kmflags) { + if (!heap->archdep.kmflags + || heap->archdep.kmflags == XNHEAP_GFP_NONCACHED) { unsigned long maddr = vma->vm_start; + if (heap->archdep.kmflags == XNHEAP_GFP_NONCACHED) + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); + while (size > 0) { if (xnarch_remap_vm_page(vma, maddr, vaddr)) return -EAGAIN; @@ -1174,9 +1178,13 @@ static inline void *__alloc_and_reserve_ /* Size must be page-aligned. */ - if (!kmflags) { - ptr = vmalloc(size); - + if (!kmflags || kmflags == XNHEAP_GFP_NONCACHED) { + if (!kmflags) + ptr = vmalloc(size); + else + ptr = __vmalloc(size, + GFP_KERNEL | __GFP_HIGHMEM, + pgprot_noncached(PAGE_KERNEL)); if (!ptr) return NULL; @@ -1217,7 +1225,7 @@ static inline void __unreserve_and_free_ vabase = (unsigned long)ptr; - if (!kmflags) { + if (!kmflags || kmflags == XNHEAP_GFP_NONCACHED) { for (vaddr = vabase; vaddr < vabase + size; vaddr += PAGE_SIZE) ClearPageReserved(virt_to_page(__va_to_kva(vaddr))); @@ -1241,6 +1249,11 @@ int xnheap_init_mapped(xnheap_t *heap, u /* Caller must have accounted for internal overhead. */ heapsize = xnheap_align(heapsize, PAGE_SIZE); + + if ((memflags & XNHEAP_GFP_NONCACHED) + && memflags != XNHEAP_GFP_NONCACHED) + return -EINVAL; + heapbase = __alloc_and_reserve_heap(heapsize, memflags); if (!heapbase) @@ -1284,11 +1297,39 @@ int xnheap_destroy_mapped(xnheap_t *heap return 0; } -EXPORT_SYMBOL(xnheap_init_mapped); -EXPORT_SYMBOL(xnheap_destroy_mapped); +#else /* !CONFIG_XENO_OPT_PERVASIVE */ +static void xnheap_free_extent(xnheap_t *heap, + void *extent, u_long size, void *cookie) +{ + xnarch_free_host_mem(extent, size); +} + +int xnheap_init_mapped(xnheap_t *heap, unsigned len, int flags) +{ + void *heapaddr = xnarch_alloc_host_mem(len); + int err; + if (heapaddr) { + err = xnheap_init(&shm->heapbase, + heapaddr, len, XNCORE_PAGE_SIZE); + if (err) + xnarch_free_host_mem(heapaddr, len); + + return err; + } + + return -ENOMEM; +} + +void xnheap_destroy_mapped(xnheap_t *heap) +{ + xnheap_destroy(heap, &xnheap_free_extent, NULL); +} #endif /* CONFIG_XENO_OPT_PERVASIVE */ +EXPORT_SYMBOL(xnheap_init_mapped); +EXPORT_SYMBOL(xnheap_destroy_mapped); + /*@}*/ EXPORT_SYMBOL(xnheap_alloc); -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* [Xenomai-core] [Patch 2/7] Define XNARCH_SHARED_HEAP_FLAGS 2008-05-02 22:30 ` [Xenomai-core] [Patch 1/7] Support for non cached memory mappings Gilles Chanteperdrix @ 2008-05-02 22:32 ` Gilles Chanteperdrix 2008-05-02 22:33 ` [Xenomai-core] [Patch 3/7] Define more atomic operations in user-space Gilles Chanteperdrix 2008-05-18 16:30 ` [Xenomai-core] [Patch 1/7] Support for non cached memory mappings Philippe Gerum 1 sibling, 1 reply; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-02 22:32 UTC (permalink / raw) To: xenomai No comment. --- asm-arm/hal.h | 7 ++++++- asm-generic/system.h | 6 ++++++ 2 files changed, 12 insertions(+), 1 deletion(-) Index: include/asm-generic/system.h =================================================================== --- include/asm-generic/system.h (revision 3738) +++ include/asm-generic/system.h (working copy) @@ -238,6 +238,12 @@ static inline int xnlock_dbg_release(xnl #define xnarch_logerr(fmt, args...) printk(KERN_ERR XNARCH_PROMPT fmt, ##args) #define xnarch_printf(fmt, args...) printk(KERN_INFO XNARCH_PROMPT fmt, ##args) +#ifndef RTHAL_SHARED_HEAP_FLAGS +#define XNARCH_SHARED_HEAP_FLAGS 0 +#else /* !RTHAL_SHARED_HEAP_FLAGS */ +#define XNARCH_SHARED_HEAP_FLAGS RTHAL_SHARED_HEAP_FLAGS +#endif /* !RTHAL_SHARED_HEAP_FLAGS */ + typedef cpumask_t xnarch_cpumask_t; #ifdef CONFIG_SMP Index: include/asm-arm/hal.h =================================================================== --- include/asm-arm/hal.h (revision 3738) +++ include/asm-arm/hal.h (working copy) @@ -108,10 +108,15 @@ static inline __attribute_const__ unsign #include <asm/processor.h> #include <asm/ipipe.h> #include <asm/mach/irq.h> +#include <asm/cacheflush.h> #define RTHAL_TIMER_IRQ __ipipe_mach_timerint -#define RTHAL_SHARED_HEAP_FLAGS XNHEAP_GFP_NONCACHED +#ifdef CONFIG_XENO_OPT_PERVASIVE +#define RTHAL_SHARED_HEAP_FLAGS (cache_is_vivt() ? XNHEAP_GFP_NONCACHED : 0) +#else /* !CONFIG_XENO_OPT_PERVASIVE */ +#define RTHAL_SHARED_HEAP_FLAGS 0 +#endif /* !CONFIG_XENO_OPT_PERVASIVE */ #define rthal_grab_control() do { } while(0) #define rthal_release_control() do { } while(0) -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* [Xenomai-core] [Patch 3/7] Define more atomic operations in user-space 2008-05-02 22:32 ` [Xenomai-core] [Patch 2/7] Define XNARCH_SHARED_HEAP_FLAGS Gilles Chanteperdrix @ 2008-05-02 22:33 ` Gilles Chanteperdrix 2008-05-02 22:34 ` [Xenomai-core] [Patch 4/7] Define ARM " Gilles Chanteperdrix 0 siblings, 1 reply; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-02 22:33 UTC (permalink / raw) To: xenomai This patch now only implement the _get, _set and _cmpxchg operations for the new xnarch_atomic_intptr_t type. Since xnarch_atomic_t is now a long type, the atomic_long_t is no longer needed. --- Makefile.am | 2 +- atomic.h | 24 ++++++++++++++++++++++++ 2 files changed, 25 insertions(+), 1 deletion(-) Index: include/asm-generic/atomic.h =================================================================== --- include/asm-generic/atomic.h (revision 0) +++ include/asm-generic/atomic.h (revision 0) @@ -0,0 +1,24 @@ +#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, new) \ + (void *)(xnarch_atomic_cmpxchg((xnarch_atomic_t *)(l), \ + (long)(old), (long)(new))) + +#endif /* _XENO_ASM_GENERIC_ATOMIC_H */ Index: include/asm-generic/Makefile.am =================================================================== --- include/asm-generic/Makefile.am (revision 3738) +++ include/asm-generic/Makefile.am (working copy) @@ -1,5 +1,5 @@ includesubdir = $(includedir)/asm-generic -includesub_HEADERS = arith.h features.h hal.h syscall.h system.h wrappers.h +includesub_HEADERS = arith.h atomic.h features.h hal.h syscall.h system.h wrappers.h SUBDIRS = bits -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* [Xenomai-core] [Patch 4/7] Define ARM atomic operations in user-space 2008-05-02 22:33 ` [Xenomai-core] [Patch 3/7] Define more atomic operations in user-space Gilles Chanteperdrix @ 2008-05-02 22:34 ` Gilles Chanteperdrix 2008-05-02 22:35 ` [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin Gilles Chanteperdrix 2008-05-05 16:33 ` [Xenomai-core] [Patch 4/7] Define ARM atomic operations in user-space Gilles Chanteperdrix 0 siblings, 2 replies; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-02 22:34 UTC (permalink / raw) To: xenomai The include/asm-arm/atomic.h header now defines the xnarch_memory_barrier in addition to user-space atomic operations. The pxa3xx deserves a special treatment since it uses the ARMv6 memory barrier operation whereas being an ARMv5 for other operations, hence a special --enable-arm-mach=pxa3xx option in configure.in. --- configure.in | 13 ++ include/asm-arm/atomic.h | 238 +++++++++++++++++++++++++++++++++++++++++------ 2 files changed, 222 insertions(+), 29 deletions(-) Index: configure.in =================================================================== --- configure.in (revision 3738) +++ configure.in (working copy) @@ -166,6 +166,7 @@ if test $XENO_TARGET_ARCH = arm ; then CONFIX_XENO_ARM_EABI= unset CONFIG_XENO_ARM_SA1100 + unset CONFIG_XENO_CPU_XSC3 unset tsc_type unset CONFIG_XENO_ARM_HW_DIRECT_TSC @@ -173,7 +174,7 @@ if test $XENO_TARGET_ARCH = arm ; then AC_ARG_ENABLE(arm-mach, AS_HELP_STRING([--enable-arm-mach], [Select for which machine we are compiling. Valid machines are at91rm9200, at91sam926x, imx, imx21, integrator, -ixp4xx, pxa, s3c2410, sa1100.]), +ixp4xx, pxa, pxa3xx, s3c2410, sa1100.]), [case "$enableval" in at91rm9200) arch=4 tsc_type=__XN_TSC_TYPE_FREERUNNING;; @@ -193,6 +194,9 @@ ixp4xx, pxa, s3c2410, sa1100.]), ixp4xx|pxa) arch=5 tsc_type=__XN_TSC_TYPE_FREERUNNING;; + pxa3xx) arch=xscale3 + tsc_type=__XN_TSC_TYPE_FREERUNNING;; + s3c2410) arch=4 tsc_type=__XN_TSC_TYPE_DECREMENTER;; @@ -218,6 +222,9 @@ ixp4xx, pxa, s3c2410, sa1100.]), esac CONFIG_XENO_ARM_ARCH="$enableval" ]) + elif test $arch = xscale3; then + CONFIG_XENO_ARM_ARCH=5 + CONFIG_XENO_CPU_XSC3=y else CONFIG_XENO_ARM_ARCH=$arch fi @@ -226,6 +233,9 @@ ixp4xx, pxa, s3c2410, sa1100.]), AC_MSG_CHECKING(for ARM SA1100 architecture) AC_MSG_RESULT(${CONFIG_XENO_ARM_SA1100:-no}) + AC_MSG_CHECKING(for ARM Xscale3 architecture) + AC_MSG_RESULT(${CONFIG_XENO_CPU_XSC3:-no}) + AC_MSG_CHECKING(for TSC emulation in user-space.) if test $tsc_type; then AC_ARG_ENABLE(arm-tsc, @@ -527,6 +537,7 @@ test x$CONFIG_X86_TSC = xy && AC_DEFINE( test -n "$CONFIG_XENO_ARM_ARCH" && AC_DEFINE_UNQUOTED(CONFIG_XENO_ARM_ARCH,$CONFIG_XENO_ARM_ARCH,[config]) test x$CONFIG_XENO_ARM_SA1100 = xy && AC_DEFINE(CONFIG_XENO_ARM_SA1100,1,[config]) +test x$CONFIG_XENO_CPU_XSC3 = xy && AC_DEFINE(CONFIG_XENO_CPU_XSC3,1,[config]) test $CONFIG_XENO_ARM_HW_DIRECT_TSC && AC_DEFINE_UNQUOTED(CONFIG_XENO_ARM_HW_DIRECT_TSC,$CONFIG_XENO_ARM_HW_DIRECT_TSC,[config]) test x$CONFIG_XENO_ARM_EABI = xy && AC_DEFINE(CONFIG_XENO_ARM_EABI,1,[config]) Index: include/asm-arm/atomic.h =================================================================== --- include/asm-arm/atomic.h (revision 3738) +++ include/asm-arm/atomic.h (working copy) @@ -23,7 +23,6 @@ #ifndef _XENO_ASM_ARM_ATOMIC_H #define _XENO_ASM_ARM_ATOMIC_H - #ifdef __KERNEL__ #include <linux/bitops.h> @@ -31,11 +30,17 @@ #include <asm/system.h> #include <asm/xenomai/features.h> +typedef atomic_t atomic_counter_t; +typedef atomic_t xnarch_atomic_t; + #define xnarch_atomic_xchg(ptr,v) xchg(ptr,v) #define xnarch_memory_barrier() smp_mb() #if __LINUX_ARM_ARCH__ >= 6 -static inline void atomic_set_mask(unsigned long mask, unsigned long *addr) +#define XNARCH_HAVE_US_ATOMIC_CMPXCHG + +static inline void +xnarch_atomic_set_mask(unsigned long *addr, unsigned long mask) { unsigned long tmp, tmp2; @@ -50,7 +55,8 @@ static inline void atomic_set_mask(unsig : "cc"); } #else /* ARM_ARCH_6 */ -static inline void atomic_set_mask(unsigned long mask, unsigned long *addr) +static inline void +xnarch_atomic_set_mask(unsigned long *addr, unsigned long mask) { unsigned long flags; @@ -58,25 +64,32 @@ static inline void atomic_set_mask(unsig *addr |= mask; local_irq_restore_hw(flags); } + +#ifndef CONFIG_SMP +#define XNARCH_HAVE_US_ATOMIC_CMPXCHG +#endif /* CONFIG_SMP */ + #endif /* ARM_ARCH_6 */ -#define xnarch_atomic_set(pcounter,i) atomic_set(pcounter,i) +#define xnarch_atomic_set(pcounter,i) atomic_set((pcounter),i) #define xnarch_atomic_get(pcounter) atomic_read(pcounter) #define xnarch_atomic_inc(pcounter) atomic_inc(pcounter) #define xnarch_atomic_dec(pcounter) atomic_dec(pcounter) +#define xnarch_atomic_clear_mask(addr, mask) atomic_clear_mask((mask), (addr)) +#define xnarch_atomic_cmpxchg(pcounter, old, new) \ + atomic_cmpxchg((pcounter), (old), (new)) #define xnarch_atomic_inc_and_test(pcounter) atomic_inc_and_test(pcounter) #define xnarch_atomic_dec_and_test(pcounter) atomic_dec_and_test(pcounter) -#define xnarch_atomic_set_mask(pflags,mask) atomic_set_mask(mask,pflags) -#define xnarch_atomic_clear_mask(pflags,mask) atomic_clear_mask(mask,pflags) - -typedef atomic_t atomic_counter_t; #else /* !__KERNEL__ */ #include <asm/xenomai/features.h> #include <asm/xenomai/syscall.h> +#include <nucleus/compiler.h> + +typedef struct { volatile int counter; } xnarch_atomic_t; -typedef struct { volatile int counter; } atomic_counter_t; +#define xnarch_atomic_get(v) ((v)->counter) /* * This function doesn't exist, so you'll get a linker error @@ -129,12 +142,47 @@ __xchg(volatile void *ptr, unsigned long * Atomic operations lifted from linux/include/asm-arm/atomic.h */ #if CONFIG_XENO_ARM_ARCH >= 6 -static __inline__ int atomic_add_return(int i, atomic_counter_t *v) +#define XNARCH_HAVE_US_ATOMIC_CMPXCHG + +static __inline__ void xnarch_atomic_set(xnarch_atomic_t *v, int i) +{ + unsigned long tmp; + + __asm__ __volatile__("@ xnarch_atomic_set\n" +"1: ldrex %0, [%1]\n" +" strex %0, %2, [%1]\n" +" teq %0, #0\n" +" bne 1b" + : "=&r" (tmp) + : "r" (&v->counter), "r" (i) + : "cc"); +} + +static __inline__ int +xnarch_atomic_cmpxchg(xnarch_atomic_t *ptr, int old, int new) +{ + unsigned long oldval, res; + + do { + __asm__ __volatile__("@ xnarch_atomic_cmpxchg\n" + "ldrex %1, [%2]\n" + "mov %0, #0\n" + "teq %1, %3\n" + "strexeq %0, %4, [%2]\n" + : "=&r" (res), "=&r" (oldval) + : "r" (&ptr->counter), "Ir" (old), "r" (new) + : "cc"); + } while (res); + + return oldval; +} + +static __inline__ int xnarch_atomic_add_return(int i, xnarch_atomic_t *v) { unsigned long tmp; int result; - __asm__ __volatile__("@ atomic_add_return\n" + __asm__ __volatile__("@ xnarch_atomic_add_return\n" "1: ldrex %0, [%2]\n" " add %0, %0, %3\n" " strex %1, %0, [%2]\n" @@ -147,12 +195,12 @@ static __inline__ int atomic_add_return( return result; } -static __inline__ int atomic_sub_return(int i, atomic_counter_t *v) +static __inline__ int xnarch_atomic_sub_return(int i, xnarch_atomic_t *v) { unsigned long tmp; int result; - __asm__ __volatile__("@ atomic_sub_return\n" + __asm__ __volatile__("@ xnarch_atomic_sub_return\n" "1: ldrex %0, [%2]\n" " sub %0, %0, %3\n" " strex %1, %0, [%2]\n" @@ -165,11 +213,12 @@ static __inline__ int atomic_sub_return( return result; } -static __inline__ void atomic_set_mask(unsigned long mask, unsigned long *addr) +static __inline__ void +xnarch_atomic_set_mask(unsigned long *addr, unsigned long mask) { unsigned long tmp, tmp2; - __asm__ __volatile__("@ atomic_set_mask\n" + __asm__ __volatile__("@ xnarch_atomic_set_mask\n" "1: ldrex %0, [%2]\n" " orr %0, %0, %3\n" " strex %1, %0, [%2]\n" @@ -180,11 +229,12 @@ static __inline__ void atomic_set_mask(u : "cc"); } -static __inline__ void atomic_clear_mask(unsigned long mask, unsigned long *addr) +static __inline__ void +xnarch_atomic_clear_mask(unsigned long *addr, unsigned long mask) { unsigned long tmp, tmp2; - __asm__ __volatile__("@ atomic_clear_mask\n" + __asm__ __volatile__("@ xnarch_atomic_clear_mask\n" "1: ldrex %0, [%2]\n" " bic %0, %0, %3\n" " strex %1, %0, [%2]\n" @@ -194,8 +244,9 @@ static __inline__ void atomic_clear_mask : "r" (addr), "Ir" (mask) : "cc"); } -#else /* ARM_ARCH_6 */ -static __inline__ int atomic_add_return(int i, atomic_counter_t *v) + +#elif CONFIG_SMP +static __inline__ int xnarch_atomic_add_return(int i, xnarch_atomic_t *v) { int ret; @@ -204,7 +255,7 @@ static __inline__ int atomic_add_return( return ret; } -static __inline__ int atomic_sub_return(int i, atomic_counter_t *v) +static __inline__ int xnarch_atomic_sub_return(int i, xnarch_atomic_t *v) { int ret; @@ -213,25 +264,153 @@ static __inline__ int atomic_sub_return( return ret; } -static inline void atomic_set_mask(unsigned long mask, unsigned long *addr) +static inline void +xnarch_atomic_set_mask(unsigned long *addr, unsigned long mask) { XENOMAI_SYSCALL3(__xn_sys_arch, XENOMAI_SYSARCH_ATOMIC_SET_MASK, mask, addr); } -static inline void atomic_clear_mask(unsigned long mask, unsigned long *addr) +static inline void +xnarch_atomic_clear_mask(unsigned long *addr, unsigned long mask) { XENOMAI_SYSCALL3(__xn_sys_arch, XENOMAI_SYSARCH_ATOMIC_CLEAR_MASK, mask, addr); } -#endif /* ARM_ARCH_6 */ +#else /* ARM_ARCH <= 5 && !CONFIG_SMP */ +#define XNARCH_HAVE_US_ATOMIC_CMPXCHG + +static __inline__ void xnarch_atomic_set(xnarch_atomic_t *ptr, int val) +{ + ptr->counter = val; +} -#define xnarch_memory_barrier() __asm__ __volatile__("": : :"memory") +static __inline__ int +xnarch_atomic_cmpxchg(xnarch_atomic_t *ptr, int old, int new) +{ + register int asm_old asm("r0") = old; + register int asm_new asm("r1") = new; + register int *asm_ptr asm("r2") = (int *) &ptr->counter; + register int asm_lr asm("lr"); + register int asm_tmp asm("r3"); + + do { + asm volatile ( \ + "mov %1, #0xffff0fff\n\t" \ + "mov lr, pc\n\t" \ + "add pc, %1, #(0xffff0fc0 - 0xffff0fff)\n\t" \ + : "+r"(asm_old), "=&r"(asm_tmp), "=r"(asm_lr) \ + : "r"(asm_new), "r"(asm_ptr) \ + : "ip", "cc", "memory"); + if (likely(!asm_old)) + return old; + } while ((asm_old = *asm_ptr) == old); + return asm_old; +} + +static __inline__ int xnarch_atomic_add_return(int i, xnarch_atomic_t *v) +{ + register int asm_old asm("r0"); + register int asm_new asm("r1"); + register int *asm_ptr asm("r2") = (int *) &v->counter; + register int asm_lr asm("lr"); + register int asm_tmp asm("r3"); + + asm volatile ( \ + "1: @ xnarch_atomic_add\n\t" \ + "ldr %0, [%4]\n\t" \ + "mov %1, #0xffff0fff\n\t" \ + "add lr, pc, #4\n\t" \ + "add %3, %0, %5\n\t"\ + "add pc, %1, #(0xffff0fc0 - 0xffff0fff)\n\t" \ + "bcc 1b" \ + : "=&r" (asm_old), "=&r"(asm_tmp), "=r"(asm_lr), "=r"(asm_new) \ + : "r" (asm_ptr), "rIL"(i) \ + : "ip", "cc", "memory"); + return asm_new; +} + +static __inline__ int xnarch_atomic_sub_return(int i, xnarch_atomic_t *v) +{ + register int asm_old asm("r0"); + register int asm_new asm("r1"); + register int *asm_ptr asm("r2") = (int *) &v->counter; + register int asm_lr asm("lr"); + register int asm_tmp asm("r3"); + + asm volatile ( \ + "1: @ xnarch_atomic_sub\n\t" \ + "ldr %0, [%4]\n\t" \ + "mov %1, #0xffff0fff\n\t" \ + "add lr, pc, #4\n\t" \ + "sub %3, %0, %5\n\t"\ + "add pc, %1, #(0xffff0fc0 - 0xffff0fff)\n\t" \ + "bcc 1b" \ + : "=&r" (asm_old), "=&r"(asm_tmp), "=r"(asm_lr), "=r"(asm_new) \ + : "r" (asm_ptr), "rIL"(i) \ + : "ip", "cc", "memory"); + return asm_new; +} + +static __inline__ void xnarch_atomic_set_mask(xnarch_atomic_t *v, long mask) +{ + register int asm_old asm("r0"); + register int asm_new asm("r1"); + register int *asm_ptr asm("r2") = (int *) &v->counter; + register int asm_lr asm("lr"); + register int asm_tmp asm("r3"); + + asm volatile ( \ + "1: @ xnarch_atomic_set_mask\n\t" \ + "ldr %0, [%4]\n\t" \ + "mov %1, #0xffff0fff\n\t" \ + "add lr, pc, #4\n\t" \ + "orr %3, %0, %5\n\t"\ + "add pc, %1, #(0xffff0fc0 - 0xffff0fff)\n\t" \ + "bcc 1b" \ + : "=&r" (asm_old), "=&r"(asm_tmp), "=r"(asm_lr), "=r"(asm_new) \ + : "r" (asm_ptr), "rIL"(mask) \ + : "ip", "cc", "memory"); +} + +static __inline__ void xnarch_atomic_clear_mask(xnarch_atomic_t *v, long mask) +{ + register int asm_old asm("r0"); + register int asm_new asm("r1"); + register int *asm_ptr asm("r2") = (int *) &v->counter; + register int asm_lr asm("lr"); + register int asm_tmp asm("r3"); + + asm volatile ( \ + "1: @ xnarch_atomic_clear_mask\n\t" \ + "ldr %0, [%4]\n\t" \ + "mov %1, #0xffff0fff\n\t" \ + "add lr, pc, #4\n\t" \ + "bic %3, %0, %5\n\t" \ + "add pc, %1, #(0xffff0fc0 - 0xffff0fff)\n\t" \ + "bcc 1b" \ + : "=&r" (asm_old), "=&r"(asm_tmp), "=r"(asm_lr), "=r"(asm_new) \ + : "r" (asm_ptr), "rIL"(mask) \ + : "ip", "cc", "memory"); +} + + +#endif /* ARM_ARCH <= 5 && !CONFIG_SMP */ + +#if CONFIG_XENO_ARM_ARCH >= 7 +#define xnarch_memory_barrier() \ + __asm__ __volatile__ ("dmb" : : : "memory") +#elif defined(CONFIG_XENO_CPU_XSC3) || CONFIG_XENO_ARM_ARCH == 6 +#define xnarch_memory_barrier() \ + __asm__ __volatile__ ("mcr p15, 0, %0, c7, c10, 5" \ + : : "r" (0) : "memory") +#else /* CONFIG_XENO_ARM_ARCH <= 5 */ +#define xnarch_memory_barrier() \ + __asm__ __volatile__ ("": : :"memory") +#endif /* CONFIG_XENO_ARM_ARCH <= 5 */ -#define xnarch_atomic_inc(pcounter) (void) atomic_add_return(1, pcounter) -#define xnarch_atomic_dec_and_test(pcounter) (atomic_sub_return(1, pcounter) == 0) -#define xnarch_atomic_set_mask(pflags,mask) atomic_set_mask(mask,pflags) -#define xnarch_atomic_clear_mask(pflags,mask) atomic_clear_mask(mask,pflags) +#define xnarch_atomic_inc(pcounter) (void) xnarch_atomic_add_return(1, pcounter) +#define xnarch_atomic_dec_and_test(pcounter) (xnarch_atomic_sub_return(1, pcounter) == 0) #define cpu_relax() xnarch_memory_barrier() #define xnarch_read_memory_barrier() xnarch_memory_barrier() @@ -241,6 +420,9 @@ static inline void atomic_clear_mask(uns 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 -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin 2008-05-02 22:34 ` [Xenomai-core] [Patch 4/7] Define ARM " Gilles Chanteperdrix @ 2008-05-02 22:35 ` Gilles Chanteperdrix 2008-05-02 22:36 ` [Xenomai-core] [Patch 6/7] Re-implementation of mutexes, kernel-space support Gilles Chanteperdrix 2008-05-18 16:40 ` [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin Philippe Gerum 2008-05-05 16:33 ` [Xenomai-core] [Patch 4/7] Define ARM atomic operations in user-space Gilles Chanteperdrix 1 sibling, 2 replies; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-02 22:35 UTC (permalink / raw) To: xenomai The two syscalls defined in the posix skin now moved to the sys skin, they are used in user-space by include/asm-generic/bits/bind.h and the new header include/asm-generic/bits/current.h. The global and process-specific shared heaps are now part of this patch. --- include/asm-generic/bits/Makefile.am | 1 include/asm-generic/bits/bind.h | 121 +++++++++++++++++++++++++++++++++++ include/asm-generic/bits/current.h | 14 ++++ include/asm-generic/syscall.h | 2 include/nucleus/Makefile.am | 1 include/nucleus/sys_ppd.h | 37 ++++++++++ include/posix/syscall.h | 1 ksrc/nucleus/Kconfig | 25 +++++++ ksrc/nucleus/module.c | 19 ++++- ksrc/nucleus/shadow.c | 103 ++++++++++++++++++++++++++++- src/skins/posix/thread.c | 4 + 11 files changed, 323 insertions(+), 5 deletions(-) Index: include/asm-generic/syscall.h =================================================================== --- include/asm-generic/syscall.h (revision 3738) +++ include/asm-generic/syscall.h (working copy) @@ -30,6 +30,8 @@ #define __xn_sys_info 4 /* xnshadow_get_info(muxid,&info) */ #define __xn_sys_arch 5 /* r = xnarch_local_syscall(args) */ #define __xn_sys_trace 6 /* r = xntrace_xxx(...) */ +#define __xn_sys_sem_heap 7 +#define __xn_sys_current 8 #define XENOMAI_LINUX_DOMAIN 0 #define XENOMAI_XENO_DOMAIN 1 Index: ksrc/nucleus/Kconfig =================================================================== --- ksrc/nucleus/Kconfig (revision 3738) +++ ksrc/nucleus/Kconfig (working copy) @@ -158,6 +158,31 @@ config XENO_OPT_SYS_STACKPOOLSZ default 0 endif +config XENO_OPT_SEM_HEAPSZ + int "Size of private semaphores heap (Kb)" + default 12 + help + + Xenomai implementation of user-space semaphores relies on heaps + shared between kernel and user-space. This configuration entry + allow to set the size of the heap used for private semaphores. + + Note that each semaphore will allocate 4 or 8 bytes of memory, + so, the default of 12 Kb allows creating many semaphores. + +config XENO_OPT_GLOBAL_SEM_HEAPSZ + int "Size of global semaphores heap (Kb)" + default 12 + help + + Xenomai implementation of user-space semaphores relies on heaps + shared between kernel and user-space. This configuration entry + allow to set the size of the heap used for semaphores shared + between several processes. + + Note that each semaphore will allocate 4 or 8 bytes of memory, + so, the default of 12 Kb allows creating many semaphores. + config XENO_OPT_STATS bool "Statistics collection" depends on PROC_FS Index: ksrc/nucleus/module.c =================================================================== --- ksrc/nucleus/module.c (revision 3738) +++ ksrc/nucleus/module.c (working copy) @@ -28,6 +28,7 @@ #include <nucleus/timer.h> #include <nucleus/heap.h> #include <nucleus/version.h> +#include <nucleus/sys_ppd.h> #ifdef CONFIG_XENO_OPT_PIPE #include <nucleus/pipe.h> #endif /* CONFIG_XENO_OPT_PIPE */ @@ -50,6 +51,8 @@ u_long xnmod_sysheap_size; int xeno_nucleus_status = -EINVAL; +struct xnsys_ppd __xnsys_global_ppd; + void xnmod_alloc_glinks(xnqueue_t *freehq) { xngholder_t *sholder, *eholder; @@ -1156,6 +1159,14 @@ int __init __xeno_sys_init(void) if (err) goto fail; + err = xnheap_init_mapped(&__xnsys_global_ppd.sem_heap, + CONFIG_XENO_OPT_GLOBAL_SEM_HEAPSZ * 1024, + XNARCH_SHARED_HEAP_FLAGS ?: + (CONFIG_XENO_OPT_GLOBAL_SEM_HEAPSZ <= 128 + ? GFP_USER : 0)); + if (err) + goto cleanup_arch; + #ifdef __KERNEL__ #ifdef CONFIG_PROC_FS xnpod_init_proc(); @@ -1167,7 +1178,7 @@ int __init __xeno_sys_init(void) err = xnpipe_mount(); if (err) - goto cleanup_arch; + goto cleanup_proc; #endif /* CONFIG_XENO_OPT_PIPE */ #ifdef CONFIG_XENO_OPT_PERVASIVE @@ -1207,7 +1218,7 @@ int __init __xeno_sys_init(void) #ifdef CONFIG_XENO_OPT_PIPE xnpipe_umount(); - cleanup_arch: + cleanup_proc: #endif /* CONFIG_XENO_OPT_PIPE */ @@ -1215,6 +1226,8 @@ int __init __xeno_sys_init(void) xnpod_delete_proc(); #endif /* CONFIG_PROC_FS */ + cleanup_arch: + xnarch_exit(); #endif /* __KERNEL__ */ @@ -1254,6 +1267,8 @@ void __exit __xeno_sys_exit(void) #endif /* CONFIG_XENO_OPT_PIPE */ #endif /* __KERNEL__ */ + xnheap_destroy_mapped(&__xnsys_global_ppd.sem_heap); + if (nkmsgbuf) xnarch_free_host_mem(nkmsgbuf, XNPOD_FATAL_BUFSZ); Index: ksrc/nucleus/shadow.c =================================================================== --- ksrc/nucleus/shadow.c (revision 3738) +++ ksrc/nucleus/shadow.c (working copy) @@ -51,6 +51,7 @@ #include <nucleus/ppd.h> #include <nucleus/trace.h> #include <nucleus/stat.h> +#include <nucleus/sys_ppd.h> #include <asm/xenomai/features.h> #include <asm/xenomai/syscall.h> #include <asm/xenomai/bits/shadow.h> @@ -1558,11 +1559,11 @@ static void stringify_feature_set(u_long static int xnshadow_sys_bind(struct pt_regs *regs) { + xnshadow_ppd_t *ppd = NULL, *sys_ppd = NULL; unsigned magic = __xn_reg_arg1(regs); u_long featdep = __xn_reg_arg2(regs); u_long abirev = __xn_reg_arg3(regs); u_long infarg = __xn_reg_arg4(regs); - xnshadow_ppd_t *ppd = NULL; xnfeatinfo_t finfo; u_long featmis; int muxid, err; @@ -1636,6 +1637,36 @@ static int xnshadow_sys_bind(struct pt_r earlier than that, do not refer to nkpod until the latter had a chance to call xnpod_init(). */ + xnlock_get_irqsave(&nklock, s); + sys_ppd = ppd_lookup(0, current->mm); + xnlock_put_irqrestore(&nklock, s); + + if (sys_ppd) + goto muxid_eventcb; + + sys_ppd = (xnshadow_ppd_t *) muxtable[0].props->eventcb(XNSHADOW_CLIENT_ATTACH, + current); + + if (IS_ERR(sys_ppd)) { + err = PTR_ERR(sys_ppd); + goto fail; + } + + if (!sys_ppd) + goto muxid_eventcb; + + + sys_ppd->key.muxid = 0; + sys_ppd->key.mm = current->mm; + + if (ppd_insert(sys_ppd) == -EBUSY) { + /* In case of concurrent binding (which can not happen with + Xenomai libraries), detach right away the second ppd. */ + muxtable[0].props->eventcb(XNSHADOW_CLIENT_DETACH, sys_ppd); + sys_ppd = NULL; + } + + muxid_eventcb: if (!muxtable[muxid].props->eventcb) goto eventcb_done; @@ -1652,7 +1683,7 @@ static int xnshadow_sys_bind(struct pt_r if (IS_ERR(ppd)) { err = PTR_ERR(ppd); - goto fail; + goto fail_destroy_sys_ppd; } if (!ppd) @@ -1689,6 +1720,11 @@ static int xnshadow_sys_bind(struct pt_r err = -ENOSYS; + fail_destroy_sys_ppd: + if (sys_ppd) { + ppd_remove(sys_ppd); + muxtable[0].props->eventcb(XNSHADOW_CLIENT_DETACH, sys_ppd); + } fail: if (!xnarch_atomic_get(&muxtable[muxid].refcnt)) xnarch_atomic_dec(&muxtable[muxid].refcnt); @@ -1856,6 +1892,32 @@ static int xnshadow_sys_trace(struct pt_ return err; } +struct heap_info { + xnheap_t *addr; + unsigned size; +}; + +static int xnshadow_sys_sem_heap(struct pt_regs *regs) +{ + struct heap_info hinfo, __user *us_hinfo; + unsigned global; + + global = __xn_reg_arg2(regs); + us_hinfo = (struct heap_info __user *) __xn_reg_arg1(regs); + hinfo.addr = &xnsys_ppd_get(global)->sem_heap; + hinfo.size = xnheap_extentsize(hinfo.addr); + + return __xn_safe_copy_to_user(us_hinfo, &hinfo, sizeof(*us_hinfo)); +} + +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); + + return __xn_safe_copy_to_user(us_current, &cur, sizeof(*us_current)); +} + static xnsysent_t __systab[] = { [__xn_sys_migrate] = {&xnshadow_sys_migrate, __xn_exec_current}, [__xn_sys_arch] = {&xnshadow_sys_arch, __xn_exec_any}, @@ -1864,15 +1926,50 @@ static xnsysent_t __systab[] = { [__xn_sys_completion] = {&xnshadow_sys_completion, __xn_exec_lostage}, [__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}, + [__xn_sys_current] = {&xnshadow_sys_current, __xn_exec_any}, }; +static void *xnshadow_sys_event(int event, void *data) +{ + struct xnsys_ppd *p; + int err; + + switch(event) { + case XNSHADOW_CLIENT_ATTACH: + p = (struct xnsys_ppd *) xnarch_alloc_host_mem(sizeof(*p)); + if (!p) + return ERR_PTR(-ENOMEM); + + err = xnheap_init_mapped(&p->sem_heap, + CONFIG_XENO_OPT_SEM_HEAPSZ * 1024, + XNARCH_SHARED_HEAP_FLAGS ?: + (CONFIG_XENO_OPT_SEM_HEAPSZ <= 128 + ? GFP_USER : 0)); + if (err) { + xnarch_free_host_mem(p, sizeof(*p)); + return ERR_PTR(err); + } + + return &p->ppd; + + case XNSHADOW_CLIENT_DETACH: + p = ppd2sys((xnshadow_ppd_t *) data); + + xnheap_destroy_mapped(&p->sem_heap); + + return NULL; + } + + return ERR_PTR(-EINVAL); +} static struct xnskin_props __props = { .name = "sys", .magic = 0x434F5245, .nrcalls = sizeof(__systab) / sizeof(__systab[0]), .systab = __systab, - .eventcb = NULL, + .eventcb = xnshadow_sys_event, .timebasep = NULL, .module = NULL }; Index: include/posix/syscall.h =================================================================== --- include/posix/syscall.h (revision 3738) +++ include/posix/syscall.h (working copy) @@ -46,6 +46,7 @@ #define __pse51_mutex_lock 20 #define __pse51_mutex_timedlock 21 #define __pse51_mutex_trylock 22 +#define __pse51_check_init __pse51_mutex_trylock #define __pse51_mutex_unlock 23 #define __pse51_cond_init 24 #define __pse51_cond_destroy 25 Index: src/skins/posix/thread.c =================================================================== --- src/skins/posix/thread.c (revision 3738) +++ src/skins/posix/thread.c (working copy) @@ -24,6 +24,7 @@ #include <sys/types.h> #include <semaphore.h> #include <posix/syscall.h> +#include <asm-generic/bits/current.h> extern int __pse51_muxid; @@ -56,6 +57,7 @@ int __wrap_pthread_setschedparam(pthread if (!err && promoted) { old_sigharden_handler = signal(SIGHARDEN, &__pthread_sigharden_handler); + xeno_set_current(); if (policy != SCHED_OTHER) XENOMAI_SYSCALL1(__xn_sys_migrate, XENOMAI_XENO_DOMAIN); } @@ -132,6 +134,8 @@ static void *__pthread_trampoline(void * start = iargs->start; cookie = iargs->arg; + xeno_set_current(); + __real_sem_post(&iargs->sync); if (!err) { Index: include/asm-generic/bits/current.h =================================================================== --- include/asm-generic/bits/current.h (revision 0) +++ include/asm-generic/bits/current.h (revision 0) @@ -0,0 +1,14 @@ +#ifndef _XENO_ASM_GENERIC_CURRENT_H +#define _XENO_ASM_GENERIC_CURRENT_H + +#include <pthread.h> + +extern pthread_key_t xeno_current_key; + +extern void xeno_set_current(void); + +static inline void *xeno_get_current(void) +{ + return pthread_getspecific(xeno_current_key); +} +#endif /* _XENO_ASM_GENERIC_CURRENT_H */ Index: include/asm-generic/bits/Makefile.am =================================================================== --- include/asm-generic/bits/Makefile.am (revision 3738) +++ include/asm-generic/bits/Makefile.am (working copy) @@ -2,6 +2,7 @@ includesubdir = $(includedir)/asm-generi includesub_HEADERS = \ bind.h \ + current.h \ heap.h \ intr.h \ mlock_alert.h \ Index: include/nucleus/sys_ppd.h =================================================================== --- include/nucleus/sys_ppd.h (revision 0) +++ include/nucleus/sys_ppd.h (revision 0) @@ -0,0 +1,37 @@ +#ifndef _XENO_NUCLEUS_SYS_PPD_H +#define _XENO_NUCLEUS_SYS_PPD_H + +#include <nucleus/ppd.h> +#include <nucleus/heap.h> + +struct xnsys_ppd { + xnshadow_ppd_t ppd; + xnheap_t sem_heap; + +#define ppd2sys(addr) container_of(addr, struct xnsys_ppd, ppd) +}; + +extern struct xnsys_ppd __xnsys_global_ppd; + +#ifdef CONFIG_XENO_OPT_PERVASIVE + +static inline struct xnsys_ppd *xnsys_ppd_get(int global) +{ + xnshadow_ppd_t *ppd; + + if (global || !(ppd = xnshadow_ppd_get(0))) + return &__xnsys_global_ppd; + + return ppd2sys(ppd); +} + +#else /* !CONFIG_XENO_OPT_PERVASIVE */ + +static inline struct xnsys_ppd *xnsys_ppd_get(int global) +{ + return &__xnsys_global_ppd; +} + +#endif /* !CONFIG_XENO_OPT_PERVASIVE */ + +#endif /* _XENO_NUCLEUS_SYS_PPD_H */ Index: include/nucleus/Makefile.am =================================================================== --- include/nucleus/Makefile.am (revision 3738) +++ include/nucleus/Makefile.am (working copy) @@ -20,6 +20,7 @@ includesub_HEADERS = \ stat.h \ synch.h \ system.h \ + sys_ppd.h \ thread.h \ timebase.h \ timer.h \ Index: include/asm-generic/bits/bind.h =================================================================== --- include/asm-generic/bits/bind.h (revision 3738) +++ include/asm-generic/bits/bind.h (working copy) @@ -6,10 +6,89 @@ #include <string.h> #include <errno.h> #include <signal.h> +#include <pthread.h> +#include <sys/ioctl.h> #include <asm/xenomai/syscall.h> +__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); + pthread_setspecific(xeno_current_key, kthread_cb); +} + +static void init_current_key(void) +{ + int err = pthread_key_create(&xeno_current_key, NULL); + if (err) { + fprintf(stderr, "Xenomai: error creating TSD key: %s\n", + strerror(err)); + exit(1); + } +} + +__attribute__ ((weak)) +unsigned long xeno_sem_heap[2] = { 0, 0 }; + void xeno_handle_mlock_alert(int sig); +static void *map_sem_heap(unsigned shared) +{ + struct heap_info { + void *addr; + unsigned size; + } hinfo; + int fd, err; + + fd = open("/dev/rtheap", O_RDWR, 0); + if (fd < 0) { + fprintf(stderr, "Xenomai: open: %m\n"); + return MAP_FAILED; + } + + err = XENOMAI_SYSCALL2(__xn_sys_sem_heap, &hinfo, shared); + if (err < 0) { + fprintf(stderr, "Xenomai: sys_sem_heap: %m\n"); + return MAP_FAILED; + } + + err = ioctl(fd, 0, hinfo.addr); + if (err < 0) { + fprintf(stderr, "Xenomai: ioctl: %m\n"); + return MAP_FAILED; + } + + hinfo.addr = mmap(NULL, hinfo.size, + PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + close(fd); + + return hinfo.addr; +} + +static void unmap_sem_heap(unsigned long heap_addr, unsigned shared) +{ + struct heap_info { + void *addr; + unsigned size; + } hinfo; + int err; + + err = XENOMAI_SYSCALL2(__xn_sys_sem_heap, &hinfo, shared); + if (err < 0) { + fprintf(stderr, "Xenomai: sys_sem_heap: %m\n"); + return; + } + + munmap((void *) heap_addr, hinfo.size); +} + + static inline int xeno_bind_skin(unsigned skin_magic, const char *skin, const char *module) { @@ -62,6 +141,27 @@ 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); + + /* 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); + xeno_sem_heap[0] = (unsigned long) map_sem_heap(0); + if (xeno_sem_heap[0] == (unsigned long) MAP_FAILED) { + perror("Xenomai: mmap(local sem heap)"); + exit(EXIT_FAILURE); + } + + /* Even if we forked the global semaphore heap did not change, no need + to map it anew */ + if (!xeno_sem_heap[1]) { + xeno_sem_heap[1] = (unsigned long) map_sem_heap(1); + if (xeno_sem_heap[1] == (unsigned long) MAP_FAILED) { + perror("Xenomai: mmap(global sem heap)"); + exit(EXIT_FAILURE); + } + } + return muxid; } @@ -105,6 +205,27 @@ 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); + + /* 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); + xeno_sem_heap[0] = (unsigned long) map_sem_heap(0); + if (xeno_sem_heap[0] == (unsigned long) MAP_FAILED) { + perror("Xenomai: mmap(local sem heap)"); + exit(EXIT_FAILURE); + } + + /* Even if we forked the global semaphore heap did not change, no need + to map it anew */ + if (!xeno_sem_heap[1]) { + xeno_sem_heap[1] = (unsigned long) map_sem_heap(1); + if (xeno_sem_heap[1] == (unsigned long) MAP_FAILED) { + perror("Xenomai: mmap(global sem heap)"); + exit(EXIT_FAILURE); + } + } + return muxid; } -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* [Xenomai-core] [Patch 6/7] Re-implementation of mutexes, kernel-space support. 2008-05-02 22:35 ` [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin Gilles Chanteperdrix @ 2008-05-02 22:36 ` Gilles Chanteperdrix 2008-05-02 22:38 ` [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support Gilles Chanteperdrix 2008-05-18 16:40 ` [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin Philippe Gerum 1 sibling, 1 reply; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-02 22:36 UTC (permalink / raw) To: xenomai No comment. --- include/posix/pthread.h | 56 ++++---- ksrc/skins/posix/cb_lock.h | 84 ++++++++++++ ksrc/skins/posix/cond.c | 41 ++++- ksrc/skins/posix/mutex.c | 308 +++++++++++++++++++++++++++------------------ ksrc/skins/posix/mutex.h | 125 ++++++++++++++---- ksrc/skins/posix/shm.c | 40 ----- ksrc/skins/posix/syscall.c | 300 ++++++++++++++++++++++++++++++++++++++++++- 7 files changed, 725 insertions(+), 229 deletions(-) Index: ksrc/skins/posix/shm.c =================================================================== --- ksrc/skins/posix/shm.c (revision 3738) +++ ksrc/skins/posix/shm.c (working copy) @@ -90,14 +90,6 @@ static void pse51_shm_init(pse51_shm_t * appendq(&pse51_shmq, &shm->link); } -#ifndef CONFIG_XENO_OPT_PERVASIVE -static void pse51_free_heap_extent(xnheap_t *heap, - void *extent, u_long size, void *cookie) -{ - xnarch_free_host_mem(extent, size); -} -#endif /* !CONFIG_XENO_OPT_PERVASIVE */ - /* Must be called nklock locked, irq off. */ static void pse51_shm_destroy(pse51_shm_t * shm, int force) { @@ -111,11 +103,7 @@ static void pse51_shm_destroy(pse51_shm_ if (shm->addr) { xnheap_free(&shm->heapbase, shm->addr); -#ifdef CONFIG_XENO_OPT_PERVASIVE xnheap_destroy_mapped(&shm->heapbase); -#else /* !CONFIG_XENO_OPT_PERVASIVE. */ - xnheap_destroy(&shm->heapbase, &pse51_free_heap_extent, NULL); -#endif /* !CONFIG_XENO_OPT_PERVASIVE. */ shm->addr = NULL; shm->size = 0; @@ -534,37 +522,19 @@ int ftruncate(int fd, off_t len) memcpy(addr, shm->addr, size); xnheap_free(&shm->heapbase, shm->addr); -#ifdef CONFIG_XENO_OPT_PERVASIVE xnheap_destroy_mapped(&shm->heapbase); -#else /* !CONFIG_XENO_OPT_PERVASIVE. */ - xnheap_destroy(&shm->heapbase, &pse51_free_heap_extent, - NULL); -#endif /* !CONFIG_XENO_OPT_PERVASIVE. */ shm->addr = NULL; shm->size = 0; } if (len) { -#ifdef CONFIG_XENO_OPT_PERVASIVE - int flags = len <= 128 * 1024 ? GFP_USER : 0; - err = -xnheap_init_mapped(&shm->heapbase, len, flags); -#else /* !CONFIG_XENO_OPT_PERVASIVE. */ - { - void *heapaddr = xnarch_alloc_host_mem(len); - - if (heapaddr) - err = - -xnheap_init(&shm->heapbase, - heapaddr, len, - XNCORE_PAGE_SIZE); - else - err = ENOMEM; + int flags = (XNARCH_SHARED_HEAP_FLAGS ?: + len <= 128 * 1024 ? GFP_USER : 0); - if (err) - goto err_up; - } -#endif /* !CONFIG_XENO_OPT_PERVASIVE. */ + err = -xnheap_init_mapped(&shm->heapbase, len, flags); + if (err) + goto err_up; shm->size = xnheap_max_contiguous(&shm->heapbase); shm->addr = xnheap_alloc(&shm->heapbase, shm->size); Index: ksrc/skins/posix/cb_lock.h =================================================================== --- ksrc/skins/posix/cb_lock.h (revision 0) +++ ksrc/skins/posix/cb_lock.h (revision 0) @@ -0,0 +1,84 @@ +#ifndef CB_LOCK_H +#define CB_LOCK_H + +#include <asm/xenomai/atomic.h> + +#ifndef __KERNEL__ +typedef void xnthread_t; +#endif /* __KERNEL__ */ + +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG + +#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))) + +static __inline__ int __cb_try_read_lock(xnarch_atomic_t *lock) +{ + unsigned val = xnarch_atomic_get(lock); + while (likely(val != -1)) { + unsigned old = xnarch_atomic_cmpxchg(lock, val, val + 1); + if (likely(old == val)) + return 0; + val = old; + } + return -EBUSY; +} + +static __inline__ void __cb_read_unlock(xnarch_atomic_t *lock) +{ + unsigned old, val = xnarch_atomic_get(lock); + while (likely(val != -1)) { + old = xnarch_atomic_cmpxchg(lock, val, val - 1); + if (likely(old == val)) + return; + val = old; + } +} + +static __inline__ int __cb_try_write_lock(xnarch_atomic_t *lock) +{ + unsigned old = xnarch_atomic_cmpxchg(lock, 0, -1); + if (unlikely(old)) + return -EBUSY; + return 0; +} + +static __inline__ void __cb_force_write_lock(xnarch_atomic_t *lock) +{ + xnarch_atomic_set(lock, -1); +} + +static __inline__ void __cb_write_unlock(xnarch_atomic_t *lock) +{ + xnarch_atomic_set(lock, 0); +} +#define DECLARE_CB_LOCK_FLAGS(name) struct { } name __attribute__((unused)) +#define cb_try_read_lock(lock, flags) __cb_try_read_lock(lock) +#define cb_read_unlock(lock, flags) __cb_read_unlock(lock) +#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 /* !XNARCH_HAVE_US_ATOMIC_CMPXCHG */ +#ifdef __KERNEL__ +#define DECLARE_CB_LOCK_FLAGS(name) spl_t name +#define cb_try_read_lock(lock, flags) \ + ({ xnlock_get_irqsave(&nklock, flags); 0 }) +#define cb_read_unlock(lock, flags) xnlock_put_irqrestore(&nklock, flags) +#define cb_try_write_lock(lock, flags) \ + ({ xnlock_get_irqsave(&nklock, flags); 0 }) +#define cb_force_write_lock(lock, flags) \ + ({ xnlock_get_irqsave(&nklock, flags); 0 }) +#define cb_write_unlock(lock, flags) xnlock_put_irqrestore(&nklock, flags) +#else /* !__KERNEL__ */ +#define DECLARE_CB_LOCK_FLAGS(name) +#define cb_try_read_lock(lock, flags) (0) +#define cb_read_unlock(lock, flags) do { } while (0) +#define cb_try_write_lock(lock, flags) (0) +#define cb_force_write_lock(lock, flags) do { } while (0) +#define cb_write_unlock(lock, flags) do { } while (0) +#endif /* !__KERNEL__ */ +#endif /* !XNARCH_HAVE_US_ATOMIC_CMPXCHG */ + +#endif /* CB_LOCK_H */ Index: include/posix/pthread.h =================================================================== --- include/posix/pthread.h (revision 3738) +++ include/posix/pthread.h (working copy) @@ -93,19 +93,6 @@ typedef struct pse51_threadattr { /* pthread_mutexattr_t and pthread_condattr_t fit on 32 bits, for compatibility with libc. */ -typedef struct pse51_mutexattr { - unsigned magic: 24; - unsigned type: 2; - unsigned protocol: 2; - unsigned pshared: 1; -} pthread_mutexattr_t; - -typedef struct pse51_condattr { - unsigned magic: 24; - unsigned clock: 2; - unsigned pshared: 1; -} pthread_condattr_t; - struct pse51_key; typedef struct pse51_key *pthread_key_t; @@ -169,24 +156,44 @@ struct timespec; #define PTHREAD_IENABLE 0 #define PTHREAD_IDISABLE 1 +struct pse51_mutexattr { + unsigned magic: 24; + unsigned type: 2; + unsigned protocol: 2; + unsigned pshared: 1; +}; + +struct pse51_condattr { + unsigned magic: 24; + unsigned clock: 2; + unsigned pshared: 1; +}; + struct pse51_mutex; union __xeno_mutex { - pthread_mutex_t native_mutex; - struct __shadow_mutex { - unsigned magic; - struct pse51_mutex *mutex; - } shadow_mutex; + pthread_mutex_t native_mutex; + struct __shadow_mutex { + unsigned magic; + unsigned lockcnt; + struct pse51_mutex *mutex; + xnarch_atomic_t lock; + union { + unsigned owner_offset; + xnarch_atomic_intptr_t *owner; + }; + struct pse51_mutexattr attr; + } shadow_mutex; }; struct pse51_cond; union __xeno_cond { - pthread_cond_t native_cond; - struct __shadow_cond { - unsigned magic; - struct pse51_cond *cond; - } shadow_cond; + pthread_cond_t native_cond; + struct __shadow_cond { + unsigned magic; + struct pse51_cond *cond; + } shadow_cond; }; struct pse51_interrupt; @@ -194,6 +201,9 @@ struct pse51_interrupt; typedef struct pse51_interrupt *pthread_intr_t; #if defined(__KERNEL__) || defined(__XENO_SIM__) +typedef struct pse51_mutexattr pthread_mutexattr_t; + +typedef struct pse51_condattr pthread_condattr_t; #ifdef __cplusplus extern "C" { Index: ksrc/skins/posix/mutex.h =================================================================== --- ksrc/skins/posix/mutex.h (revision 3738) +++ ksrc/skins/posix/mutex.h (working copy) @@ -21,6 +21,7 @@ #include <posix/internal.h> #include <posix/thread.h> +#include <posix/cb_lock.h> typedef struct pse51_mutex { xnsynch_t synchbase; @@ -29,47 +30,58 @@ typedef struct pse51_mutex { #define link2mutex(laddr) \ ((pse51_mutex_t *)(((char *)laddr) - offsetof(pse51_mutex_t, link))) + xnarch_atomic_intptr_t *owner; pthread_mutexattr_t attr; - unsigned count; /* lock count. */ - unsigned condvars; /* count of condition variables using this - mutex. */ pse51_kqueues_t *owningq; } pse51_mutex_t; +extern pthread_mutexattr_t pse51_default_mutex_attr; + void pse51_mutexq_cleanup(pse51_kqueues_t *q); void pse51_mutex_pkg_init(void); void pse51_mutex_pkg_cleanup(void); -/* Interruptible versions of pthread_mutex_*. Exposed for use by syscall.c. */ +/* Internal mutex functions, exposed for use by syscall.c. */ int pse51_mutex_timedlock_break(struct __shadow_mutex *shadow, int timed, xnticks_t to); -/* must be called with nklock locked, interrupts off. */ -static inline int pse51_mutex_trylock_internal(xnthread_t *cur, - struct __shadow_mutex *shadow, - unsigned count) +int pse51_mutex_check_init(struct __shadow_mutex *shadow, + const pthread_mutexattr_t *attr); + +int pse51_mutex_init_internal(struct __shadow_mutex *shadow, + pse51_mutex_t *mutex, + xnarch_atomic_intptr_t *ownerp, + const pthread_mutexattr_t *attr); + +void pse51_mutex_destroy_internal(pse51_mutex_t *mutex, + pse51_kqueues_t *q); + +static inline xnthread_t * +pse51_mutex_trylock_internal(xnthread_t *cur, + struct __shadow_mutex *shadow, unsigned count) { pse51_mutex_t *mutex = shadow->mutex; + xnthread_t *owner; if (xnpod_unblockable_p()) - return EPERM; + return ERR_PTR(-EPERM); if (!pse51_obj_active(shadow, PSE51_MUTEX_MAGIC, struct __shadow_mutex)) - return EINVAL; + return ERR_PTR(-EINVAL); #if XENO_DEBUG(POSIX) if (mutex->owningq != pse51_kqueues(mutex->attr.pshared)) - return EPERM; + return ERR_PTR(-EPERM); #endif /* XENO_DEBUG(POSIX) */ - if (mutex->count) - return EBUSY; + owner = xnarch_atomic_intptr_cmpxchg(mutex->owner, NULL, cur); + if (unlikely(owner)) + return owner; - xnsynch_set_owner(&mutex->synchbase, cur); - mutex->count = count; - return 0; + shadow->lockcnt = count; + return NULL; } /* must be called with nklock locked, interrupts off. */ @@ -81,31 +93,86 @@ static inline int pse51_mutex_timedlock_ { pse51_mutex_t *mutex; + xnthread_t *owner, *old; + spl_t s; int err; - err = pse51_mutex_trylock_internal(cur, shadow, count); - if (err != EBUSY) - return err; + retry_lock: + owner = pse51_mutex_trylock_internal(cur, shadow, count); + if (likely(!owner) || IS_ERR(owner)) + return PTR_ERR(owner); mutex = shadow->mutex; - if (xnsynch_owner(&mutex->synchbase) == cur) - return EBUSY; + if (clear_claimed(owner) == cur) + return -EBUSY; + /* Set bit 0, so that mutex_unlock will know that the mutex is claimed. + Hold the nklock, for mutual exclusion with slow mutex_unlock. */ + xnlock_get_irqsave(&nklock, s); + while(!test_claimed(owner)) { + old = xnarch_atomic_intptr_cmpxchg(mutex->owner, + owner, set_claimed(owner, 1)); + if (likely(old == owner)) + break; + if (old == NULL) { + /* Owner called fast mutex_unlock + (on another cpu) */ + xnlock_put_irqrestore(&nklock, s); + goto retry_lock; + } + owner = old; + } + + xnsynch_set_owner(&mutex->synchbase, clear_claimed(owner)); if (timed) xnsynch_sleep_on(&mutex->synchbase, abs_to, XN_REALTIME); else xnsynch_sleep_on(&mutex->synchbase, XN_INFINITE, XN_RELATIVE); - if (xnthread_test_info(cur, XNBREAK)) - return EINTR; - - if (xnthread_test_info(cur, XNRMID)) - return EINVAL; - - if (xnthread_test_info(cur, XNTIMEO)) - return ETIMEDOUT; + if (xnthread_test_info(cur, XNBREAK)) { + err = -EINTR; + goto error; + } + if (xnthread_test_info(cur, XNRMID)) { + err = -EINVAL; + goto error; + } + if (xnthread_test_info(cur, XNTIMEO)) { + err = -ETIMEDOUT; + goto error; + } + + xnarch_atomic_intptr_set + (mutex->owner, + set_claimed(cur, xnsynch_nsleepers(&mutex->synchbase))); + shadow->lockcnt = count; + xnlock_put_irqrestore(&nklock, s); return 0; + + error: + if (!xnsynch_nsleepers(&mutex->synchbase)) + xnarch_atomic_intptr_set + (mutex->owner, + clear_claimed(xnarch_atomic_intptr_get(mutex->owner))); + xnlock_put_irqrestore(&nklock, s); + return err; +} + +static inline void pse51_mutex_unlock_internal(xnthread_t *cur, + pse51_mutex_t *mutex) +{ + spl_t s; + + if (likely(xnarch_atomic_intptr_cmpxchg(mutex->owner, cur, NULL) == cur)) + return; + + xnlock_get_irqsave(&nklock, s); + if (xnsynch_wakeup_one_sleeper(&mutex->synchbase)) + xnpod_schedule(); + else + xnarch_atomic_intptr_set(mutex->owner, NULL); + xnlock_put_irqrestore(&nklock, s); } #endif /* !_POSIX_MUTEX_H */ Index: ksrc/skins/posix/mutex.c =================================================================== --- ksrc/skins/posix/mutex.c (revision 3738) +++ ksrc/skins/posix/mutex.c (working copy) @@ -47,23 +47,74 @@ * *@{*/ +#include <nucleus/sys_ppd.h> #include <posix/mutex.h> -static pthread_mutexattr_t default_attr; +pthread_mutexattr_t pse51_default_mutex_attr; -static void pse51_mutex_destroy_internal(pse51_mutex_t *mutex, - pse51_kqueues_t *q) +int pse51_mutex_check_init(struct __shadow_mutex *shadow, + const pthread_mutexattr_t *attr) { + xnqueue_t *mutexq; + + if (!attr) + attr = &pse51_default_mutex_attr; + + mutexq = &pse51_kqueues(attr->pshared)->mutexq; + + if (shadow->magic == PSE51_MUTEX_MAGIC) { + xnholder_t *holder; + for (holder = getheadq(mutexq); holder; + holder = nextq(mutexq, holder)) + if (holder == &shadow->mutex->link) + /* mutex is already in the queue. */ + return -EBUSY; + } + + return 0; +} + +int pse51_mutex_init_internal(struct __shadow_mutex *shadow, + pse51_mutex_t *mutex, + xnarch_atomic_intptr_t *ownerp, + const pthread_mutexattr_t *attr) +{ + xnflags_t synch_flags = XNSYNCH_PRIO | XNSYNCH_NOPIP; + struct xnsys_ppd *sys_ppd; + pse51_kqueues_t *kq; spl_t s; + if (!attr) + attr = &pse51_default_mutex_attr; + + if (attr->magic != PSE51_MUTEX_ATTR_MAGIC) + return -EINVAL; + + kq = pse51_kqueues(attr->pshared); + sys_ppd = xnsys_ppd_get(attr->pshared); + + shadow->magic = PSE51_MUTEX_MAGIC; + atomic_set(&shadow->lock, -1); + shadow->mutex = mutex; + shadow->attr = *attr; + shadow->lockcnt = 0; + shadow->owner_offset = xnheap_mapped_offset(&sys_ppd->sem_heap, ownerp); + + if (attr->protocol == PTHREAD_PRIO_INHERIT) + synch_flags |= XNSYNCH_PIP; + + xnsynch_init(&mutex->synchbase, synch_flags); + inith(&mutex->link); + mutex->attr = *attr; + mutex->owner = ownerp; + mutex->owningq = kq; + xnarch_atomic_intptr_set(ownerp, NULL); + xnlock_get_irqsave(&nklock, s); - removeq(&q->mutexq, &mutex->link); - /* synchbase wait queue may not be empty only when this function is called - from pse51_mutex_pkg_cleanup, hence the absence of xnpod_schedule(). */ - xnsynch_destroy(&mutex->synchbase); + appendq(&kq->mutexq, &mutex->link); xnlock_put_irqrestore(&nklock, s); - xnfree(mutex); + return 0; } /** @@ -83,72 +134,84 @@ static void pse51_mutex_destroy_internal * - EBUSY, the mutex @a mx was already initialized; * - ENOMEM, insufficient memory exists in the system heap to initialize the * mutex, increase CONFIG_XENO_OPT_SYS_HEAPSZ. + * - EAGAIN, insufficient memory exists in the semaphore heap to initialize the + * mutex, increase CONFIG_XENO_OPT_GLOBAL_SEM_HEAPSZ for a process-shared + * mutex, or CONFG_XENO_OPT_SEM_HEAPSZ for a process-private mutex. * * @see * <a href="http://www.opengroup.org/onlinepubs/000095399/functions/pthread_mutex_init.html"> * Specification.</a> * */ -int pthread_mutex_init(pthread_mutex_t * mx, const pthread_mutexattr_t * attr) +int pthread_mutex_init(pthread_mutex_t *mx, const pthread_mutexattr_t *attr) { struct __shadow_mutex *shadow = &((union __xeno_mutex *)mx)->shadow_mutex; - xnflags_t synch_flags = XNSYNCH_PRIO | XNSYNCH_NOPIP; + DECLARE_CB_LOCK_FLAGS(s); pse51_mutex_t *mutex; - xnqueue_t *mutexq; - spl_t s; + xnarch_atomic_intptr_t *ownerp; int err; if (!attr) - attr = &default_attr; + attr = &pse51_default_mutex_attr; + if (unlikely(cb_try_read_lock(&shadow->lock, s))) + goto checked; + + err = pse51_mutex_check_init(shadow, attr); +#ifndef XNARCH_HAVE_US_ATOMIC_CMPXCHG + cb_read_unlock(&shadow->lock, s); + if (err) + return -err; +#else /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ + if (err) { + cb_read_unlock(&shadow->lock, s); + return -err; + } +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ + + checked: mutex = (pse51_mutex_t *) xnmalloc(sizeof(*mutex)); if (!mutex) return ENOMEM; - xnlock_get_irqsave(&nklock, s); - - if (attr->magic != PSE51_MUTEX_ATTR_MAGIC) { - err = EINVAL; - goto error; + ownerp = (xnarch_atomic_intptr_t *) + xnheap_alloc(&xnsys_ppd_get(attr->pshared)->sem_heap, + sizeof(xnarch_atomic_intptr_t)); + if (!ownerp) { + xnfree(mutex); + return EAGAIN; } - mutexq = &pse51_kqueues(attr->pshared)->mutexq; - - if (shadow->magic == PSE51_MUTEX_MAGIC) { - xnholder_t *holder; - for (holder = getheadq(mutexq); holder; - holder = nextq(mutexq, holder)) - if (holder == &shadow->mutex->link) { - /* mutex is already in the queue. */ - err = EBUSY; - goto error; - } + cb_force_write_lock(&shadow->lock, s); + err = pse51_mutex_init_internal(shadow, mutex, ownerp, attr); + cb_write_unlock(&shadow->lock, s); + + if (err) { + xnfree(mutex); + xnheap_free(&xnsys_ppd_get(attr->pshared)->sem_heap, ownerp); } + return -err; +} - shadow->magic = PSE51_MUTEX_MAGIC; - shadow->mutex = mutex; - - if (attr->protocol == PTHREAD_PRIO_INHERIT) - synch_flags |= XNSYNCH_PIP; - - xnsynch_init(&mutex->synchbase, synch_flags); - inith(&mutex->link); - mutex->attr = *attr; - mutex->count = 0; - mutex->condvars = 0; - mutex->owningq = pse51_kqueues(attr->pshared); - - appendq(mutexq, &mutex->link); +void pse51_mutex_destroy_internal(pse51_mutex_t *mutex, + pse51_kqueues_t *q) +{ + spl_t s; + xnlock_get_irqsave(&nklock, s); + removeq(&q->mutexq, &mutex->link); + /* synchbase wait queue may not be empty only when this function is called + from pse51_mutex_pkg_cleanup, hence the absence of xnpod_schedule(). */ + xnsynch_destroy(&mutex->synchbase); xnlock_put_irqrestore(&nklock, s); - return 0; - - error: - xnlock_put_irqrestore(&nklock, s); + if (mutex->attr.pshared) + xnheap_free(&xnsys_ppd_get(1)->sem_heap, mutex->owner); + /* We do not free the owner if the mutex is not pshared, because when + this function is called from pse51_mutexq_cleanup, the sem_heap has + been destroyed, and we have no way to find it back. */ xnfree(mutex); - return err; } /** @@ -176,30 +239,34 @@ int pthread_mutex_destroy(pthread_mutex_ { struct __shadow_mutex *shadow = &((union __xeno_mutex *)mx)->shadow_mutex; + DECLARE_CB_LOCK_FLAGS(s); pse51_mutex_t *mutex; - spl_t s; - xnlock_get_irqsave(&nklock, s); + if (unlikely(cb_try_write_lock(&shadow->lock, s))) + return EBUSY; if (!pse51_obj_active(shadow, PSE51_MUTEX_MAGIC, struct __shadow_mutex)) { - xnlock_put_irqrestore(&nklock, s); + cb_write_unlock(&shadow->lock, s); return EINVAL; } mutex = shadow->mutex; if (pse51_kqueues(mutex->attr.pshared) != mutex->owningq) { - xnlock_put_irqrestore(&nklock, s); + cb_write_unlock(&shadow->lock, s); return EPERM; } - if (mutex->count || mutex->condvars) { - xnlock_put_irqrestore(&nklock, s); + if (xnarch_atomic_intptr_get(mutex->owner)) { + cb_write_unlock(&shadow->lock, s); return EBUSY; } pse51_mark_deleted(shadow); - xnlock_put_irqrestore(&nklock, s); + cb_write_unlock(&shadow->lock, s); + if (!mutex->attr.pshared) + xnheap_free(&xnsys_ppd_get(mutex->attr.pshared)->sem_heap, + mutex->owner); pse51_mutex_destroy_internal(mutex, pse51_kqueues(mutex->attr.pshared)); return 0; @@ -210,20 +277,19 @@ int pse51_mutex_timedlock_break(struct _ { xnthread_t *cur = xnpod_current_thread(); pse51_mutex_t *mutex; - int err; spl_t s; - - xnlock_get_irqsave(&nklock, s); + int err; err = pse51_mutex_timedlock_internal(cur, shadow, 1, timed, abs_to); - if (err != EBUSY) + if (err != -EBUSY) goto unlock_and_return; mutex = shadow->mutex; - switch (mutex->attr.type) { + switch(mutex->attr.type) { case PTHREAD_MUTEX_NORMAL: /* Attempting to relock a normal mutex, deadlock. */ + xnlock_get_irqsave(&nklock, s); for (;;) { if (timed) xnsynch_sleep_on(&mutex->synchbase, @@ -233,41 +299,41 @@ int pse51_mutex_timedlock_break(struct _ XN_INFINITE, XN_RELATIVE); if (xnthread_test_info(cur, XNBREAK)) { - err = EINTR; + err = -EINTR; break; } if (xnthread_test_info(cur, XNTIMEO)) { - err = ETIMEDOUT; + err = -ETIMEDOUT; break; } if (xnthread_test_info(cur, XNRMID)) { - err = EINVAL; + err = -EINVAL; break; } } + xnlock_put_irqrestore(&nklock, s); break; case PTHREAD_MUTEX_ERRORCHECK: - err = EDEADLK; + err = -EDEADLK; break; case PTHREAD_MUTEX_RECURSIVE: - if (mutex->count == UINT_MAX) { - err = EAGAIN; + if (shadow->lockcnt == UINT_MAX) { + err = -EAGAIN; break; } - ++mutex->count; + ++shadow->lockcnt; err = 0; } unlock_and_return: - xnlock_put_irqrestore(&nklock, s); - return err; + } /** @@ -298,33 +364,36 @@ int pse51_mutex_timedlock_break(struct _ * Specification.</a> * */ -int pthread_mutex_trylock(pthread_mutex_t * mx) +int pthread_mutex_trylock(pthread_mutex_t *mx) { struct __shadow_mutex *shadow = &((union __xeno_mutex *)mx)->shadow_mutex; - xnthread_t *cur = xnpod_current_thread(); + xnthread_t *owner, *cur = xnpod_current_thread(); + DECLARE_CB_LOCK_FLAGS(s); int err; - spl_t s; - xnlock_get_irqsave(&nklock, s); + if (unlikely(cb_try_read_lock(&shadow->lock, s))) + return EINVAL; - err = pse51_mutex_trylock_internal(cur, shadow, 1); + owner = pse51_mutex_trylock_internal(cur, shadow, 1); + if (likely(!owner) || IS_ERR(owner)) + return -PTR_ERR(owner); - if (err == EBUSY) { + err = EBUSY; + if (clear_claimed(owner) == cur) { pse51_mutex_t *mutex = shadow->mutex; - if (mutex->attr.type == PTHREAD_MUTEX_RECURSIVE - && xnsynch_owner(&mutex->synchbase) == cur) { - if (mutex->count == UINT_MAX) + if (mutex->attr.type == PTHREAD_MUTEX_RECURSIVE) { + if (shadow->lockcnt == UINT_MAX) err = EAGAIN; else { - ++mutex->count; + ++shadow->lockcnt; err = 0; } } } - xnlock_put_irqrestore(&nklock, s); + cb_read_unlock(&shadow->lock, s); return err; } @@ -369,12 +438,18 @@ int pthread_mutex_lock(pthread_mutex_t * { struct __shadow_mutex *shadow = &((union __xeno_mutex *)mx)->shadow_mutex; + DECLARE_CB_LOCK_FLAGS(s); int err; + if (unlikely(cb_try_read_lock(&shadow->lock, s))) + return EINVAL; + do { err = pse51_mutex_timedlock_break(shadow, 0, XN_INFINITE); } while (err == EINTR); + cb_read_unlock(&shadow->lock, s); + return err; } @@ -416,40 +491,20 @@ int pthread_mutex_timedlock(pthread_mute { struct __shadow_mutex *shadow = &((union __xeno_mutex *)mx)->shadow_mutex; + DECLARE_CB_LOCK_FLAGS(s); int err; + if (unlikely(cb_try_read_lock(&shadow->lock, s))) + return EINVAL; + do { err = pse51_mutex_timedlock_break(shadow, 1, ts2ticks_ceil(to) + 1); } while (err == EINTR); - return err; -} - -/* must be called with nklock locked, interrupts off. - - Note: the function mutex_save_count() in cond.c is very similar to this - function. -*/ -static inline int mutex_unlock_internal(xnthread_t *cur, - struct __shadow_mutex *shadow) -{ - pse51_mutex_t *mutex; - - if (!pse51_obj_active(shadow, PSE51_MUTEX_MAGIC, struct __shadow_mutex)) - return EINVAL; - - mutex = shadow->mutex; - - if (xnsynch_owner(&mutex->synchbase) != cur || mutex->count != 1) - return EPERM; - - if (xnsynch_wakeup_one_sleeper(&mutex->synchbase)) - xnpod_schedule(); - else - mutex->count = 0; + cb_read_unlock(&shadow->lock, s); - return 0; + return err; } /** @@ -488,28 +543,41 @@ int pthread_mutex_unlock(pthread_mutex_t struct __shadow_mutex *shadow = &((union __xeno_mutex *)mx)->shadow_mutex; xnthread_t *cur = xnpod_current_thread(); + DECLARE_CB_LOCK_FLAGS(s); + pse51_mutex_t *mutex; int err; - spl_t s; if (xnpod_root_p() || xnpod_interrupt_p()) - return EPERM; + return -EPERM; - xnlock_get_irqsave(&nklock, s); + if (unlikely(cb_try_read_lock(&shadow->lock, s))) + return EINVAL; - err = mutex_unlock_internal(cur, shadow); + if (!pse51_obj_active(shadow, + PSE51_MUTEX_MAGIC, struct __shadow_mutex)) { + err = EINVAL; + goto out; + } - if (err == EPERM) { - pse51_mutex_t *mutex = shadow->mutex; + mutex = shadow->mutex; + + if (clear_claimed(xnarch_atomic_intptr_get(mutex->owner)) != cur) { + err = EPERM; + goto out; + } - if (mutex->attr.type == PTHREAD_MUTEX_RECURSIVE - && xnsynch_owner(&mutex->synchbase) == cur - && mutex->count) { - --mutex->count; - err = 0; - } + err = 0; + if (shadow->lockcnt > 1) { + /* Mutex is recursive */ + --shadow->lockcnt; + cb_read_unlock(&shadow->lock, s); + return 0; } - xnlock_put_irqrestore(&nklock, s); + pse51_mutex_unlock_internal(cur, mutex); + + out: + cb_read_unlock(&shadow->lock, s); return err; } @@ -536,7 +604,7 @@ void pse51_mutexq_cleanup(pse51_kqueues_ void pse51_mutex_pkg_init(void) { initq(&pse51_global_kqueues.mutexq); - pthread_mutexattr_init(&default_attr); + pthread_mutexattr_init(&pse51_default_mutex_attr); } void pse51_mutex_pkg_cleanup(void) Index: ksrc/skins/posix/cond.c =================================================================== --- ksrc/skins/posix/cond.c (revision 3738) +++ ksrc/skins/posix/cond.c (working copy) @@ -229,15 +229,16 @@ static inline int mutex_save_count(xnthr mutex = shadow->mutex; - if (xnsynch_owner(&mutex->synchbase) != cur || mutex->count == 0) + if (clear_claimed(xnarch_atomic_intptr_get(mutex->owner)) != cur) return EPERM; - *count_ptr = mutex->count; + *count_ptr = shadow->lockcnt; - if (xnsynch_wakeup_one_sleeper(&mutex->synchbase)) - mutex->count = 1; - else - mutex->count = 0; + if (likely(xnarch_atomic_intptr_cmpxchg(mutex->owner, cur, NULL) == cur)) + return 0; + + if (!xnsynch_wakeup_one_sleeper(&mutex->synchbase)) + xnarch_atomic_intptr_set(mutex->owner, NULL); /* Do not reschedule here, releasing the mutex and suspension must be done atomically in pthread_cond_*wait. */ @@ -287,10 +288,8 @@ int pse51_cond_timedwait_prologue(xnthre goto unlock_and_return; /* Bind mutex to cond. */ - if (cond->mutex == NULL) { + if (cond->mutex == NULL) cond->mutex = mutex->mutex; - ++mutex->mutex->condvars; - } /* Wait for another thread to signal the condition. */ if (timed) @@ -349,11 +348,8 @@ int pse51_cond_timedwait_epilogue(xnthre /* Unbind mutex and cond, if no other thread is waiting, if the job was not already done. */ if (!xnsynch_nsleepers(&cond->synchbase) - && cond->mutex == mutex->mutex) { - - --mutex->mutex->condvars; + && cond->mutex == mutex->mutex) cond->mutex = NULL; - } thread_cancellation_point(cur); @@ -419,9 +415,15 @@ int pthread_cond_wait(pthread_cond_t * c struct __shadow_mutex *mutex = &((union __xeno_mutex *)mx)->shadow_mutex; xnthread_t *cur = xnpod_current_thread(); + DECLARE_CB_LOCK_FLAGS(s); unsigned count; int err; +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG + if (unlikely(cb_try_read_lock(&mutex->lock, s))) + return EINVAL; +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ + err = pse51_cond_timedwait_prologue(cur, cond, mutex, &count, 0, XN_INFINITE); @@ -430,6 +432,10 @@ int pthread_cond_wait(pthread_cond_t * c mutex, count)) ; +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG + cb_read_unlock(&mutex->lock, s); +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ + return err != EINTR ? err : 0; } @@ -481,6 +487,11 @@ int pthread_cond_timedwait(pthread_cond_ unsigned count; int err; +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG + if (unlikely(cb_try_read_lock(&mutex->lock, s))) + return EINVAL; +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ + err = pse51_cond_timedwait_prologue(cur, cond, mutex, &count, 1, ts2ticks_ceil(abstime) + 1); @@ -489,6 +500,10 @@ int pthread_cond_timedwait(pthread_cond_ mutex, count)) ; +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG + cb_read_unlock(&mutex->lock, s); +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ + return err != EINTR ? err : 0; } Index: ksrc/skins/posix/syscall.c =================================================================== --- ksrc/skins/posix/syscall.c (revision 3738) +++ ksrc/skins/posix/syscall.c (working copy) @@ -23,6 +23,7 @@ #include <asm/xenomai/wrappers.h> #include <nucleus/jhash.h> #include <nucleus/ppd.h> +#include <nucleus/sys_ppd.h> #include <posix/syscall.h> #include <posix/posix.h> #include <posix/thread.h> @@ -884,6 +885,7 @@ static int __pthread_mutexattr_setpshare return __xn_safe_copy_to_user((void __user *)uattrp, &attr, sizeof(*uattrp)); } +#ifndef XNARCH_HAVE_US_ATOMIC_CMPXCHG static int __pthread_mutex_init(struct pt_regs *regs) { pthread_mutexattr_t locattr, *attr, *uattrp; @@ -941,54 +943,293 @@ static int __pthread_mutex_destroy(struc static int __pthread_mutex_lock(struct pt_regs *regs) { union __xeno_mutex mx, *umx; + DECLARE_CB_LOCK_FLAGS(s); + int err; umx = (union __xeno_mutex *)__xn_reg_arg1(regs); if (__xn_safe_copy_from_user(&mx.shadow_mutex, (void __user *)&umx->shadow_mutex, - sizeof(mx.shadow_mutex))) + offsetof(struct __shadow_mutex, lock))) + return -EFAULT; + + if (unlikely(cb_try_read_lock(&mx.shadow_mutex.lock, s))) + return -EINVAL; + + err = pse51_mutex_timedlock_break(&mx.shadow_mutex, 0, XN_INFINITE); + + cb_read_unlock(&mx.shadow_mutex.lock); + + if (!err && + __xn_safe_copy_to_user((void __user *)&umx->shadow_mutex.lockcnt, + &mx.shadow_mutex.lockcnt, + sizeof(umx->shadow_mutex.lockcnt))) return -EFAULT; - return -pse51_mutex_timedlock_break(&mx.shadow_mutex, 0, XN_INFINITE); + return -err } static int __pthread_mutex_timedlock(struct pt_regs *regs) { union __xeno_mutex mx, *umx; + DECLARE_CB_LOCK_FLAGS(s); struct timespec ts; + int err; umx = (union __xeno_mutex *)__xn_reg_arg1(regs); if (__xn_safe_copy_from_user(&mx.shadow_mutex, (void __user *)&umx->shadow_mutex, - sizeof(mx.shadow_mutex))) + offsetof(struct __shadow_mutex, lock))) return -EFAULT; if (__xn_safe_copy_from_user(&ts, (void __user *)__xn_reg_arg2(regs), sizeof(ts))) return -EFAULT; - return -pse51_mutex_timedlock_break(&mx.shadow_mutex, - 1, ts2ticks_ceil(&ts) + 1); + if (unlikely(cb_try_read_lock(&mx.shadow_mutex.lock, s))) + return -EINVAL; + + err = pse51_mutex_timedlock_break(&mx.shadow_mutex, + 1, ts2ticks_ceil(&ts) + 1); + + cb_read_unlock(&mx.shadow_mutex.lock); + + if (!err && + __xn_safe_copy_to_user((void __user *)&umx->shadow_mutex.lockcnt, + &mx.shadow_mutex.lockcnt, + sizeof(umx->shadow_mutex.lockcnt))) + return -EFAULT; + + return -err } static int __pthread_mutex_trylock(struct pt_regs *regs) { union __xeno_mutex mx, *umx; + int err; umx = (union __xeno_mutex *)__xn_reg_arg1(regs); if (__xn_safe_copy_from_user(&mx.shadow_mutex, (void __user *)&umx->shadow_mutex, - sizeof(mx.shadow_mutex))) + offsetof(struct __shadow_mutex, lock))) return -EFAULT; - return -pthread_mutex_trylock(&mx.native_mutex); + err = pthread_mutex_trylock(&mx.native_mutex); + + if (!err && + __xn_safe_copy_to_user((void __user *)&umx->shadow_mutex.lockcnt, + &mx.shadow_mutex.lockcnt, + sizeof(umx->shadow_mutex.lockcnt))) + return -EFAULT; + + return -err; } static int __pthread_mutex_unlock(struct pt_regs *regs) { + xnthread_t *cur = xnpod_current_thread(); + struct __shadow_mutex *shadow; + union __xeno_mutex mx, *umx; + DECLARE_CB_LOCK_FLAGS(s); + pse51_mutex_t *mutex; + int err; + + if (xnpod_root_p()) + return -EPERM; + + umx = (union __xeno_mutex *)__xn_reg_arg1(regs); + + if (__xn_safe_copy_from_user(&mx.shadow_mutex, + (void __user *)&umx->shadow_mutex, + offsetof(struct __shadow_mutex, lock))) + return -EFAULT; + + shadow = &mx.shadow_mutex; + + if (unlikely(cb_try_read_lock(&shadow->lock, s))) + return -EINVAL; + + if (!pse51_obj_active(shadow, + PSE51_MUTEX_MAGIC, struct __shadow_mutex)) { + err = -EINVAL; + goto out; + } + + mutex = shadow->mutex; + + if (clear_claimed(xnarch_atomic_intptr_get(mutex->owner)) != cur) { + err = -EPERM; + goto out; + } + + err = 0; + if (shadow->lockcnt > 1) { + /* Mutex is recursive */ + --shadow->lockcnt; + cb_read_unlock(&shadow->lock, s); + + if (__xn_safe_copy_to_user((void __user *) + &umx->shadow_mutex.lockcnt, + &shadow->lockcnt, + sizeof(umx->shadow_mutex.lockcnt))) + return -EFAULT; + + return 0; + } + + pse51_mutex_unlock_internal(cur, mutex); + + out: + cb_read_unlock(&shadow->lock, s); + + return err; +} +#else /* !XNARCH_HAVE_US_ATOMIC_CMPXCHG */ +static int __pthread_mutex_check_init(struct pt_regs *regs) +{ + pthread_mutexattr_t locattr, *attr, *uattrp; + union __xeno_mutex mx, *umx; + + umx = (union __xeno_mutex *)__xn_reg_arg1(regs); + + uattrp = (pthread_mutexattr_t *) __xn_reg_arg2(regs); + + if (__xn_safe_copy_from_user(&mx.shadow_mutex, + (void __user *)&umx->shadow_mutex, + sizeof(mx.shadow_mutex))) + return -EFAULT; + + if (uattrp) { + if (__xn_safe_copy_from_user(&locattr, (void __user *) + uattrp, sizeof(locattr))) + return -EFAULT; + + attr = &locattr; + } else + attr = NULL; + + return pse51_mutex_check_init(&umx->shadow_mutex, attr); +} + +static int __pthread_mutex_init(struct pt_regs *regs) +{ + pthread_mutexattr_t locattr, *attr, *uattrp; + union __xeno_mutex mx, *umx; + pse51_mutex_t *mutex; + xnarch_atomic_intptr_t *ownerp; + int err; + + umx = (union __xeno_mutex *)__xn_reg_arg1(regs); + + uattrp = (pthread_mutexattr_t *) __xn_reg_arg2(regs); + + if (__xn_safe_copy_from_user(&mx.shadow_mutex, + (void __user *)&umx->shadow_mutex, + sizeof(mx.shadow_mutex))) + return -EFAULT; + + if (uattrp) { + if (__xn_safe_copy_from_user(&locattr, (void __user *) + uattrp, sizeof(locattr))) + return -EFAULT; + + attr = &locattr; + } else + attr = &pse51_default_mutex_attr; + + mutex = (pse51_mutex_t *) xnmalloc(sizeof(*mutex)); + if (!mutex) + return -ENOMEM; + + ownerp = (xnarch_atomic_intptr_t *) + xnheap_alloc(&xnsys_ppd_get(attr->pshared)->sem_heap, + sizeof(xnarch_atomic_intptr_t)); + if (!ownerp) { + xnfree(mutex); + return -EAGAIN; + } + + err = pse51_mutex_init_internal(&mx.shadow_mutex, mutex, ownerp, attr); + if (err) { + xnfree(mutex); + xnheap_free(&xnsys_ppd_get(attr->pshared)->sem_heap, ownerp); + return err; + } + + return __xn_safe_copy_to_user((void __user *)&umx->shadow_mutex, + &mx.shadow_mutex, sizeof(umx->shadow_mutex)); +} + +static int __pthread_mutex_destroy(struct pt_regs *regs) +{ + struct __shadow_mutex *shadow; union __xeno_mutex mx, *umx; + pse51_mutex_t *mutex; + + umx = (union __xeno_mutex *)__xn_reg_arg1(regs); + + shadow = &mx.shadow_mutex; + + if (__xn_safe_copy_from_user(shadow, + (void __user *)&umx->shadow_mutex, + sizeof(*shadow))) + return -EFAULT; + + if (!pse51_obj_active(shadow, PSE51_MUTEX_MAGIC, struct __shadow_mutex)) + return -EINVAL; + + mutex = shadow->mutex; + if (pse51_kqueues(mutex->attr.pshared) != mutex->owningq) + return -EPERM; + + if (xnarch_atomic_intptr_get(mutex->owner)) + 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, + shadow, sizeof(umx->shadow_mutex)); +} + +static int __pthread_mutex_lock(struct pt_regs *regs) +{ + struct __shadow_mutex *shadow; + union __xeno_mutex mx, *umx; + int err; + + umx = (union __xeno_mutex *)__xn_reg_arg1(regs); + + if (__xn_safe_copy_from_user(&mx.shadow_mutex, + (void __user *)&umx->shadow_mutex, + offsetof(struct __shadow_mutex, lock))) + return -EFAULT; + + shadow = &mx.shadow_mutex; + + err = pse51_mutex_timedlock_break(&mx.shadow_mutex, 0, XN_INFINITE); + + if (!err && + __xn_safe_copy_to_user((void __user *) + &umx->shadow_mutex.lockcnt, + &shadow->lockcnt, + sizeof(umx->shadow_mutex.lockcnt))) + return -EFAULT; + + return -err; +} + +static int __pthread_mutex_timedlock(struct pt_regs *regs) +{ + struct __shadow_mutex *shadow; + union __xeno_mutex mx, *umx; + struct timespec ts; + int err; umx = (union __xeno_mutex *)__xn_reg_arg1(regs); @@ -997,8 +1238,46 @@ static int __pthread_mutex_unlock(struct sizeof(mx.shadow_mutex))) return -EFAULT; - return -pthread_mutex_unlock(&mx.native_mutex); + if (__xn_safe_copy_from_user(&ts, + (void __user *)__xn_reg_arg2(regs), + sizeof(ts))) + return -EFAULT; + + shadow = &mx.shadow_mutex; + + err = pse51_mutex_timedlock_break(&mx.shadow_mutex, + 1, ts2ticks_ceil(&ts) + 1); + + if (!err && + __xn_safe_copy_to_user((void __user *) + &umx->shadow_mutex.lockcnt, + &shadow->lockcnt, + sizeof(umx->shadow_mutex.lockcnt))) + return -EFAULT; + + return -err; +} + +static int __pthread_mutex_unlock(struct pt_regs *regs) +{ + xnthread_t *cur = xnpod_current_thread(); + union __xeno_mutex mx, *umx; + + if (xnpod_root_p()) + return -EPERM; + + umx = (union __xeno_mutex *)__xn_reg_arg1(regs); + + if (__xn_safe_copy_from_user(&mx.shadow_mutex, + (void __user *)&umx->shadow_mutex, + offsetof(struct __shadow_mutex, lock))) + return -EFAULT; + + pse51_mutex_unlock_internal(cur, mx.shadow_mutex.mutex); + + return 0; } +#endif /* !XNARCH_HAVE_US_ATOMIC_CMPXCHG */ static int __pthread_condattr_init(struct pt_regs *regs) { @@ -2394,7 +2673,11 @@ static xnsysent_t __systab[] = { [__pse51_mutex_lock] = {&__pthread_mutex_lock, __xn_exec_primary}, [__pse51_mutex_timedlock] = {&__pthread_mutex_timedlock, __xn_exec_primary}, +#ifndef XNARCH_HAVE_US_ATOMIC_CMPXCHG [__pse51_mutex_trylock] = {&__pthread_mutex_trylock, __xn_exec_primary}, +#else + [__pse51_check_init] = {&__pthread_mutex_check_init, __xn_exec_any}, +#endif [__pse51_mutex_unlock] = {&__pthread_mutex_unlock, __xn_exec_primary}, [__pse51_cond_init] = {&__pthread_cond_init, __xn_exec_any}, [__pse51_cond_destroy] = {&__pthread_cond_destroy, __xn_exec_any}, @@ -2477,7 +2760,6 @@ static void *pse51_eventcb(int event, vo switch (event) { case XNSHADOW_CLIENT_ATTACH: - q = (pse51_queues_t *) xnarch_alloc_host_mem(sizeof(*q)); if (!q) return ERR_PTR(-ENOSPC); -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support. 2008-05-02 22:36 ` [Xenomai-core] [Patch 6/7] Re-implementation of mutexes, kernel-space support Gilles Chanteperdrix @ 2008-05-02 22:38 ` Gilles Chanteperdrix 2008-05-18 16:42 ` Philippe Gerum 0 siblings, 1 reply; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-02 22:38 UTC (permalink / raw) To: xenomai Since binding of the semaphore heaps is now made by xeno_skin_bind, there is much less modifications in src/skins/posix/init.c. However, I had to do something really ugly: since binding the semaphore heaps by xeno_skin_bind requires calls to open, ioctl, mmap, close and munmap, I redefined these symbols to be the __real_ variants before including bind.h. Another solution would have been to use __open (which would not have been wrapped) instead of open in bind.h and rely on the fact that the posix skin wrapped syscalls fall back to the __real variants when called for non real-time file descriptors. I do not know however, if this solution would have been portable. In particular, does uclibc also defines __open ? --- Makefile.am | 2 cond.c | 21 ++++ init.c | 26 +++++ mutex.c | 265 ++++++++++++++++++++++++++++++++++++++++++++++++++++++------ 4 files changed, 287 insertions(+), 27 deletions(-) Index: src/skins/posix/init.c =================================================================== --- src/skins/posix/init.c (revision 3738) +++ src/skins/posix/init.c (working copy) @@ -26,9 +26,23 @@ #include <posix/posix.h> #include <posix/syscall.h> #include <rtdm/syscall.h> -#include <asm-generic/bits/bind.h> #include <asm-generic/bits/mlock_alert.h> +/* asm-generic/bits/bind.h uses the following functions, so we redefine them to + be the __real variants */ +#undef open +#undef ioctl +#undef mmap +#undef close +#undef munmap +#define open __real_open +#define ioctl __real_ioctl +#define mmap __real_mmap +#define close __real_close +#define munmap __real_munmap + +#include <asm-generic/bits/bind.h> + int __pse51_muxid = -1; int __rtdm_muxid = -1; int __rtdm_fd_start = INT_MAX; @@ -91,5 +105,15 @@ void __init_posix_interface(void) exit(EXIT_FAILURE); } fork_handler_registered = 1; + + if (sizeof(struct __shadow_mutex) > sizeof(pthread_mutex_t)) { + fprintf(stderr, "sizeof(pthread_mutex_t): %d," + " sizeof(shadow_mutex): %d\n", + sizeof(pthread_mutex_t), + sizeof(struct __shadow_mutex)); + exit(EXIT_FAILURE); + } + } } + Index: src/skins/posix/mutex.c =================================================================== --- src/skins/posix/mutex.c (revision 3738) +++ src/skins/posix/mutex.c (working copy) @@ -17,10 +17,15 @@ */ #include <errno.h> -#include <posix/syscall.h> #include <pthread.h> +#include <posix/syscall.h> +#include <posix/cb_lock.h> +#include <asm-generic/bits/current.h> + +#define PSE51_MUTEX_MAGIC (0x86860303) extern int __pse51_muxid; +extern unsigned long xeno_sem_heap[2]; int __wrap_pthread_mutexattr_init(pthread_mutexattr_t *attr) { @@ -73,66 +78,280 @@ int __wrap_pthread_mutexattr_setpshared( __pse51_mutexattr_setpshared, attr, pshared); } -int __wrap_pthread_mutex_init(pthread_mutex_t * mutex, - const pthread_mutexattr_t * attr) +static xnarch_atomic_intptr_t *get_ownerp(struct __shadow_mutex *shadow) +{ + if (likely(!shadow->attr.pshared)) + return shadow->owner; + + return (xnarch_atomic_intptr_t *) (xeno_sem_heap[1] + shadow->owner_offset); +} + +int __wrap_pthread_mutex_init(pthread_mutex_t *mutex, + const pthread_mutexattr_t *attr) { union __xeno_mutex *_mutex = (union __xeno_mutex *)mutex; + struct __shadow_mutex *shadow = &_mutex->shadow_mutex; int err; - err = -XENOMAI_SKINCALL2(__pse51_muxid, - __pse51_mutex_init,&_mutex->shadow_mutex,attr); +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG + if (unlikely(cb_try_read_lock(&shadow->lock, s))) + goto checked; + + err = -XENOMAI_SKINCALL2(__pse51_muxid,__pse51_check_init,shadow,attr); + + if (err) { + cb_read_unlock(&shadow->lock, s); + return err; + } + + checked: + cb_force_write_lock(&shadow->lock, s); +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ + + err = -XENOMAI_SKINCALL2(__pse51_muxid,__pse51_mutex_init,shadow,attr); + + if (!shadow->attr.pshared) + shadow->owner = (xnarch_atomic_intptr_t *) + (xeno_sem_heap[0] + shadow->owner_offset); + + cb_write_unlock(&shadow->lock, s); + return err; } -int __wrap_pthread_mutex_destroy(pthread_mutex_t * mutex) +int __wrap_pthread_mutex_destroy(pthread_mutex_t *mutex) { union __xeno_mutex *_mutex = (union __xeno_mutex *)mutex; + struct __shadow_mutex *shadow = &_mutex->shadow_mutex; + int err; + + if (unlikely(cb_try_write_lock(&shadow->lock, s))) + return EINVAL; - return -XENOMAI_SKINCALL1(__pse51_muxid, - __pse51_mutex_destroy, &_mutex->shadow_mutex); + err = -XENOMAI_SKINCALL1(__pse51_muxid, __pse51_mutex_destroy, shadow); + + cb_write_unlock(&shadow->lock, s); + + return err; } -int __wrap_pthread_mutex_lock(pthread_mutex_t * mutex) +int __wrap_pthread_mutex_lock(pthread_mutex_t *mutex) { union __xeno_mutex *_mutex = (union __xeno_mutex *)mutex; - int err; + struct __shadow_mutex *shadow = &_mutex->shadow_mutex; + xnthread_t *cur, *owner; + int err = 0; + +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG + cur = xeno_get_current(); + if (!cur) + return EPERM; + + if (unlikely(cb_try_read_lock(&shadow->lock, s))) + return EINVAL; + + if (unlikely(shadow->magic != PSE51_MUTEX_MAGIC)) { + err = -EINVAL; + goto out; + } + + owner = xnarch_atomic_intptr_cmpxchg(get_ownerp(shadow), NULL, cur); + if (likely(!owner)) { + shadow->lockcnt = 1; + cb_read_unlock(&shadow->lock, s); + return 0; + } + + if (clear_claimed(owner) == cur) + switch(shadow->attr.type) { + case PTHREAD_MUTEX_NORMAL: + break; + + case PTHREAD_MUTEX_ERRORCHECK: + err = -EDEADLK; + goto out; + + case PTHREAD_MUTEX_RECURSIVE: + if (shadow->lockcnt == UINT_MAX) { + err = -EAGAIN; + goto out; + } + + ++shadow->lockcnt; + goto out; + } +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ do { - err = XENOMAI_SKINCALL1(__pse51_muxid, - __pse51_mutex_lock, - &_mutex->shadow_mutex); + err = XENOMAI_SKINCALL1(__pse51_muxid,__pse51_mutex_lock,shadow); } while (err == -EINTR); +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG + out: + cb_read_unlock(&shadow->lock, s); +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ + return -err; } -int __wrap_pthread_mutex_timedlock(pthread_mutex_t * mutex, +int __wrap_pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *to) { union __xeno_mutex *_mutex = (union __xeno_mutex *)mutex; - int err; + struct __shadow_mutex *shadow = &_mutex->shadow_mutex; + xnthread_t *cur, *owner; + int err = 0; + +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG + cur = xeno_get_current(); + if (!cur) + return EPERM; + + if (unlikely(cb_try_read_lock(&shadow->lock, s))) + return EINVAL; + + if (shadow->magic != PSE51_MUTEX_MAGIC) { + err = -EINVAL; + goto out; + } + + owner = xnarch_atomic_intptr_cmpxchg(get_ownerp(shadow), NULL, cur); + if (likely(!owner)) { + shadow->lockcnt = 1; + cb_read_unlock(&shadow->lock, s); + return 0; + } + + if (clear_claimed(owner) == cur) + switch(shadow->attr.type) { + case PTHREAD_MUTEX_NORMAL: + break; + + case PTHREAD_MUTEX_ERRORCHECK: + err = -EDEADLK; + goto out; + + case PTHREAD_MUTEX_RECURSIVE: + if (shadow->lockcnt == UINT_MAX) { + err = -EAGAIN; + goto out; + } + + ++shadow->lockcnt; + goto out; + } +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ do { err = XENOMAI_SKINCALL2(__pse51_muxid, - __pse51_mutex_timedlock, - &_mutex->shadow_mutex, to); + __pse51_mutex_timedlock, shadow, to); } while (err == -EINTR); +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG + out: + cb_read_unlock(&shadow->lock, s); +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ + return -err; } -int __wrap_pthread_mutex_trylock(pthread_mutex_t * mutex) +int __wrap_pthread_mutex_trylock(pthread_mutex_t *mutex) { union __xeno_mutex *_mutex = (union __xeno_mutex *)mutex; + struct __shadow_mutex *shadow = &_mutex->shadow_mutex; + xnthread_t *cur, *owner; + int err = 0; + +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG + cur = xeno_get_current(); + if (!cur) + return EPERM; + + if (unlikely(cb_try_read_lock(&shadow->lock, s))) + return EINVAL; + + if (unlikely(shadow->magic != PSE51_MUTEX_MAGIC)) { + err = -EINVAL; + goto out; + } + + owner = xnarch_atomic_intptr_cmpxchg(get_ownerp(shadow), NULL, cur); + if (likely(!owner)) { + shadow->lockcnt = 1; + cb_read_unlock(&shadow->lock, s); + return 0; + } + + err = -EBUSY; + if (clear_claimed(owner) == cur + && shadow->attr.type == PTHREAD_MUTEX_RECURSIVE) { + if (shadow->lockcnt == UINT_MAX) + err = -EAGAIN; + else { + ++shadow->lockcnt; + err = 0; + } + } + + out: + cb_read_unlock(&shadow->lock, s); - return -XENOMAI_SKINCALL1(__pse51_muxid, - __pse51_mutex_trylock, &_mutex->shadow_mutex); + return -err; + +#else /* !XNARCH_HAVE_US_ATOMIC_CMPXCHG */ + + return -XENOMAI_SKINCALL1(__pse51_muxid, __pse51_mutex_trylock, shadow); + +#endif /* !XNARCH_HAVE_US_ATOMIC_CMPXCHG */ } -int __wrap_pthread_mutex_unlock(pthread_mutex_t * mutex) +int __wrap_pthread_mutex_unlock(pthread_mutex_t *mutex) { union __xeno_mutex *_mutex = (union __xeno_mutex *)mutex; + struct __shadow_mutex *shadow = &_mutex->shadow_mutex; - return -XENOMAI_SKINCALL1(__pse51_muxid, - __pse51_mutex_unlock, &_mutex->shadow_mutex); +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG + xnarch_atomic_intptr_t *ownerp; + xnthread_t *cur; + int err = 0; + + cur = xeno_get_current(); + if (!cur) + return EPERM; + + if (unlikely(cb_try_read_lock(&shadow->lock, s))) + return EINVAL; + + if (unlikely(shadow->magic != PSE51_MUTEX_MAGIC)) { + err = -EINVAL; + goto out_err; + } + + ownerp = get_ownerp(shadow); + if (unlikely(clear_claimed(xnarch_atomic_intptr_get(ownerp)) != cur)) { + err = -EPERM; + goto out_err; + } + + err = 0; + if (shadow->lockcnt > 1) { + --shadow->lockcnt; + goto out; + } + + if (likely(xnarch_atomic_intptr_cmpxchg(ownerp, cur, NULL) == cur)) { + out: + cb_read_unlock(&shadow->lock, s); + return 0; + } +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ + + err = XENOMAI_SKINCALL1(__pse51_muxid, __pse51_mutex_unlock, shadow); + +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG + out_err: + cb_read_unlock(&shadow->lock, s); +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ + + return -err; } Index: src/skins/posix/cond.c =================================================================== --- src/skins/posix/cond.c (revision 3738) +++ src/skins/posix/cond.c (working copy) @@ -19,6 +19,7 @@ #include <errno.h> #include <posix/syscall.h> #include <pthread.h> +#include <posix/cb_lock.h> extern int __pse51_muxid; @@ -95,7 +96,7 @@ static void __pthread_cond_cleanup(void c->count); } -int __wrap_pthread_cond_wait(pthread_cond_t * cond, pthread_mutex_t * mutex) +int __wrap_pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) { struct pse51_cond_cleanup_t c = { .cond = (union __xeno_cond *)cond, @@ -103,6 +104,9 @@ int __wrap_pthread_cond_wait(pthread_con }; int err, oldtype; + if (cb_try_read_lock(&c.mutex->shadow_mutex.lock, s)) + return EINVAL; + pthread_cleanup_push(&__pthread_cond_cleanup, &c); pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype); @@ -118,11 +122,15 @@ int __wrap_pthread_cond_wait(pthread_con pthread_cleanup_pop(0); - if (err) + if (err) { + cb_read_unlock(&c.mutex->shadow_mutex.lock, s); return err; + } __pthread_cond_cleanup(&c); + cb_read_unlock(&c.mutex->shadow_mutex.lock, s); + pthread_testcancel(); return 0; @@ -138,6 +146,9 @@ int __wrap_pthread_cond_timedwait(pthrea }; int err, oldtype; + if (cb_try_read_lock(&c.mutex->shadow_mutex.lock, s)) + return EINVAL; + pthread_cleanup_push(&__pthread_cond_cleanup, &c); pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype); @@ -153,11 +164,15 @@ int __wrap_pthread_cond_timedwait(pthrea pthread_cleanup_pop(0); - if (err && err != ETIMEDOUT) + if (err && err != ETIMEDOUT) { + cb_read_unlock(&c.mutex->shadow_mutex.lock, s); return err; + } __pthread_cond_cleanup(&c); + cb_read_unlock(&c.mutex->shadow_mutex.lock, s); + pthread_testcancel(); return err; Index: src/skins/posix/Makefile.am =================================================================== --- src/skins/posix/Makefile.am (revision 3738) +++ src/skins/posix/Makefile.am (working copy) @@ -2,6 +2,8 @@ includedir = $(prefix)/include/posix lib_LTLIBRARIES = libpthread_rt.la +CPPFLAGS+=-I$(top_srcdir)/ksrc/skins + libpthread_rt_la_LDFLAGS = -version-info 1:0:0 -lpthread libpthread_rt_la_SOURCES = \ -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support. 2008-05-02 22:38 ` [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support Gilles Chanteperdrix @ 2008-05-18 16:42 ` Philippe Gerum 2008-05-18 17:05 ` Gilles Chanteperdrix 0 siblings, 1 reply; 34+ messages in thread From: Philippe Gerum @ 2008-05-18 16:42 UTC (permalink / raw) To: Gilles Chanteperdrix; +Cc: xenomai Gilles Chanteperdrix wrote: > Since binding of the semaphore heaps is now made by xeno_skin_bind, there is > much less modifications in src/skins/posix/init.c. However, I had to do > something really ugly: since binding the semaphore heaps by xeno_skin_bind > requires calls to open, ioctl, mmap, close and munmap, I redefined these symbols > to be the __real_ variants before including bind.h. Is there any upside to do this instead of simply calling the __real_* placeholders, since we do already provide weak wrappers for those when the linker's wrapping magic is not invoked? > Another solution would have been to use __open (which would not have been > wrapped) instead of open in bind.h and rely on the fact that the posix skin > wrapped syscalls fall back to the __real variants when called for non real-time > file descriptors. I do not know however, if this solution would have been > portable. In particular, does uclibc also defines __open ? > > --- > Makefile.am | 2 > cond.c | 21 ++++ > init.c | 26 +++++ > mutex.c | 265 ++++++++++++++++++++++++++++++++++++++++++++++++++++++------ > 4 files changed, 287 insertions(+), 27 deletions(-) > > Index: src/skins/posix/init.c > =================================================================== > --- src/skins/posix/init.c (revision 3738) > +++ src/skins/posix/init.c (working copy) > @@ -26,9 +26,23 @@ > #include <posix/posix.h> > #include <posix/syscall.h> > #include <rtdm/syscall.h> > -#include <asm-generic/bits/bind.h> > #include <asm-generic/bits/mlock_alert.h> > > +/* asm-generic/bits/bind.h uses the following functions, so we redefine them to > + be the __real variants */ > +#undef open > +#undef ioctl > +#undef mmap > +#undef close > +#undef munmap > +#define open __real_open > +#define ioctl __real_ioctl > +#define mmap __real_mmap > +#define close __real_close > +#define munmap __real_munmap > + > +#include <asm-generic/bits/bind.h> > + > int __pse51_muxid = -1; > int __rtdm_muxid = -1; > int __rtdm_fd_start = INT_MAX; > @@ -91,5 +105,15 @@ void __init_posix_interface(void) > exit(EXIT_FAILURE); > } > fork_handler_registered = 1; > + > + if (sizeof(struct __shadow_mutex) > sizeof(pthread_mutex_t)) { > + fprintf(stderr, "sizeof(pthread_mutex_t): %d," > + " sizeof(shadow_mutex): %d\n", > + sizeof(pthread_mutex_t), > + sizeof(struct __shadow_mutex)); > + exit(EXIT_FAILURE); > + } > + > } > } > + > Index: src/skins/posix/mutex.c > =================================================================== > --- src/skins/posix/mutex.c (revision 3738) > +++ src/skins/posix/mutex.c (working copy) > @@ -17,10 +17,15 @@ > */ > > #include <errno.h> > -#include <posix/syscall.h> > #include <pthread.h> > +#include <posix/syscall.h> > +#include <posix/cb_lock.h> > +#include <asm-generic/bits/current.h> > + > +#define PSE51_MUTEX_MAGIC (0x86860303) > > extern int __pse51_muxid; > +extern unsigned long xeno_sem_heap[2]; > > int __wrap_pthread_mutexattr_init(pthread_mutexattr_t *attr) > { > @@ -73,66 +78,280 @@ int __wrap_pthread_mutexattr_setpshared( > __pse51_mutexattr_setpshared, attr, pshared); > } > > -int __wrap_pthread_mutex_init(pthread_mutex_t * mutex, > - const pthread_mutexattr_t * attr) > +static xnarch_atomic_intptr_t *get_ownerp(struct __shadow_mutex *shadow) > +{ > + if (likely(!shadow->attr.pshared)) > + return shadow->owner; > + > + return (xnarch_atomic_intptr_t *) (xeno_sem_heap[1] + shadow->owner_offset); > +} > + > +int __wrap_pthread_mutex_init(pthread_mutex_t *mutex, > + const pthread_mutexattr_t *attr) > { > union __xeno_mutex *_mutex = (union __xeno_mutex *)mutex; > + struct __shadow_mutex *shadow = &_mutex->shadow_mutex; > int err; > > - err = -XENOMAI_SKINCALL2(__pse51_muxid, > - __pse51_mutex_init,&_mutex->shadow_mutex,attr); > +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG > + if (unlikely(cb_try_read_lock(&shadow->lock, s))) > + goto checked; > + > + err = -XENOMAI_SKINCALL2(__pse51_muxid,__pse51_check_init,shadow,attr); > + > + if (err) { > + cb_read_unlock(&shadow->lock, s); > + return err; > + } > + > + checked: > + cb_force_write_lock(&shadow->lock, s); > +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ > + > + err = -XENOMAI_SKINCALL2(__pse51_muxid,__pse51_mutex_init,shadow,attr); > + > + if (!shadow->attr.pshared) > + shadow->owner = (xnarch_atomic_intptr_t *) > + (xeno_sem_heap[0] + shadow->owner_offset); > + > + cb_write_unlock(&shadow->lock, s); > + > return err; > } > > -int __wrap_pthread_mutex_destroy(pthread_mutex_t * mutex) > +int __wrap_pthread_mutex_destroy(pthread_mutex_t *mutex) > { > union __xeno_mutex *_mutex = (union __xeno_mutex *)mutex; > + struct __shadow_mutex *shadow = &_mutex->shadow_mutex; > + int err; > + > + if (unlikely(cb_try_write_lock(&shadow->lock, s))) > + return EINVAL; > > - return -XENOMAI_SKINCALL1(__pse51_muxid, > - __pse51_mutex_destroy, &_mutex->shadow_mutex); > + err = -XENOMAI_SKINCALL1(__pse51_muxid, __pse51_mutex_destroy, shadow); > + > + cb_write_unlock(&shadow->lock, s); > + > + return err; > } > > -int __wrap_pthread_mutex_lock(pthread_mutex_t * mutex) > +int __wrap_pthread_mutex_lock(pthread_mutex_t *mutex) > { > union __xeno_mutex *_mutex = (union __xeno_mutex *)mutex; > - int err; > + struct __shadow_mutex *shadow = &_mutex->shadow_mutex; > + xnthread_t *cur, *owner; > + int err = 0; > + > +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG > + cur = xeno_get_current(); > + if (!cur) > + return EPERM; > + > + if (unlikely(cb_try_read_lock(&shadow->lock, s))) > + return EINVAL; > + > + if (unlikely(shadow->magic != PSE51_MUTEX_MAGIC)) { > + err = -EINVAL; > + goto out; > + } > + > + owner = xnarch_atomic_intptr_cmpxchg(get_ownerp(shadow), NULL, cur); > + if (likely(!owner)) { > + shadow->lockcnt = 1; > + cb_read_unlock(&shadow->lock, s); > + return 0; > + } > + > + if (clear_claimed(owner) == cur) > + switch(shadow->attr.type) { > + case PTHREAD_MUTEX_NORMAL: > + break; > + > + case PTHREAD_MUTEX_ERRORCHECK: > + err = -EDEADLK; > + goto out; > + > + case PTHREAD_MUTEX_RECURSIVE: > + if (shadow->lockcnt == UINT_MAX) { > + err = -EAGAIN; > + goto out; > + } > + > + ++shadow->lockcnt; > + goto out; > + } > +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ > > do { > - err = XENOMAI_SKINCALL1(__pse51_muxid, > - __pse51_mutex_lock, > - &_mutex->shadow_mutex); > + err = XENOMAI_SKINCALL1(__pse51_muxid,__pse51_mutex_lock,shadow); > } while (err == -EINTR); > > +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG > + out: > + cb_read_unlock(&shadow->lock, s); > +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ > + > return -err; > } > > -int __wrap_pthread_mutex_timedlock(pthread_mutex_t * mutex, > +int __wrap_pthread_mutex_timedlock(pthread_mutex_t *mutex, > const struct timespec *to) > { > union __xeno_mutex *_mutex = (union __xeno_mutex *)mutex; > - int err; > + struct __shadow_mutex *shadow = &_mutex->shadow_mutex; > + xnthread_t *cur, *owner; > + int err = 0; > + > +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG > + cur = xeno_get_current(); > + if (!cur) > + return EPERM; > + > + if (unlikely(cb_try_read_lock(&shadow->lock, s))) > + return EINVAL; > + > + if (shadow->magic != PSE51_MUTEX_MAGIC) { > + err = -EINVAL; > + goto out; > + } > + > + owner = xnarch_atomic_intptr_cmpxchg(get_ownerp(shadow), NULL, cur); > + if (likely(!owner)) { > + shadow->lockcnt = 1; > + cb_read_unlock(&shadow->lock, s); > + return 0; > + } > + > + if (clear_claimed(owner) == cur) > + switch(shadow->attr.type) { > + case PTHREAD_MUTEX_NORMAL: > + break; > + > + case PTHREAD_MUTEX_ERRORCHECK: > + err = -EDEADLK; > + goto out; > + > + case PTHREAD_MUTEX_RECURSIVE: > + if (shadow->lockcnt == UINT_MAX) { > + err = -EAGAIN; > + goto out; > + } > + > + ++shadow->lockcnt; > + goto out; > + } > +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ > > do { > err = XENOMAI_SKINCALL2(__pse51_muxid, > - __pse51_mutex_timedlock, > - &_mutex->shadow_mutex, to); > + __pse51_mutex_timedlock, shadow, to); > } while (err == -EINTR); > > +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG > + out: > + cb_read_unlock(&shadow->lock, s); > +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ > + > return -err; > } > > -int __wrap_pthread_mutex_trylock(pthread_mutex_t * mutex) > +int __wrap_pthread_mutex_trylock(pthread_mutex_t *mutex) > { > union __xeno_mutex *_mutex = (union __xeno_mutex *)mutex; > + struct __shadow_mutex *shadow = &_mutex->shadow_mutex; > + xnthread_t *cur, *owner; > + int err = 0; > + > +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG > + cur = xeno_get_current(); > + if (!cur) > + return EPERM; > + > + if (unlikely(cb_try_read_lock(&shadow->lock, s))) > + return EINVAL; > + > + if (unlikely(shadow->magic != PSE51_MUTEX_MAGIC)) { > + err = -EINVAL; > + goto out; > + } > + > + owner = xnarch_atomic_intptr_cmpxchg(get_ownerp(shadow), NULL, cur); > + if (likely(!owner)) { > + shadow->lockcnt = 1; > + cb_read_unlock(&shadow->lock, s); > + return 0; > + } > + > + err = -EBUSY; > + if (clear_claimed(owner) == cur > + && shadow->attr.type == PTHREAD_MUTEX_RECURSIVE) { > + if (shadow->lockcnt == UINT_MAX) > + err = -EAGAIN; > + else { > + ++shadow->lockcnt; > + err = 0; > + } > + } > + > + out: > + cb_read_unlock(&shadow->lock, s); > > - return -XENOMAI_SKINCALL1(__pse51_muxid, > - __pse51_mutex_trylock, &_mutex->shadow_mutex); > + return -err; > + > +#else /* !XNARCH_HAVE_US_ATOMIC_CMPXCHG */ > + > + return -XENOMAI_SKINCALL1(__pse51_muxid, __pse51_mutex_trylock, shadow); > + > +#endif /* !XNARCH_HAVE_US_ATOMIC_CMPXCHG */ > } > > -int __wrap_pthread_mutex_unlock(pthread_mutex_t * mutex) > +int __wrap_pthread_mutex_unlock(pthread_mutex_t *mutex) > { > union __xeno_mutex *_mutex = (union __xeno_mutex *)mutex; > + struct __shadow_mutex *shadow = &_mutex->shadow_mutex; > > - return -XENOMAI_SKINCALL1(__pse51_muxid, > - __pse51_mutex_unlock, &_mutex->shadow_mutex); > +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG > + xnarch_atomic_intptr_t *ownerp; > + xnthread_t *cur; > + int err = 0; > + > + cur = xeno_get_current(); > + if (!cur) > + return EPERM; > + > + if (unlikely(cb_try_read_lock(&shadow->lock, s))) > + return EINVAL; > + > + if (unlikely(shadow->magic != PSE51_MUTEX_MAGIC)) { > + err = -EINVAL; > + goto out_err; > + } > + > + ownerp = get_ownerp(shadow); > + if (unlikely(clear_claimed(xnarch_atomic_intptr_get(ownerp)) != cur)) { > + err = -EPERM; > + goto out_err; > + } > + > + err = 0; > + if (shadow->lockcnt > 1) { > + --shadow->lockcnt; > + goto out; > + } > + > + if (likely(xnarch_atomic_intptr_cmpxchg(ownerp, cur, NULL) == cur)) { > + out: > + cb_read_unlock(&shadow->lock, s); > + return 0; > + } > +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ > + > + err = XENOMAI_SKINCALL1(__pse51_muxid, __pse51_mutex_unlock, shadow); > + > +#ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG > + out_err: > + cb_read_unlock(&shadow->lock, s); > +#endif /* XNARCH_HAVE_US_ATOMIC_CMPXCHG */ > + > + return -err; > } > Index: src/skins/posix/cond.c > =================================================================== > --- src/skins/posix/cond.c (revision 3738) > +++ src/skins/posix/cond.c (working copy) > @@ -19,6 +19,7 @@ > #include <errno.h> > #include <posix/syscall.h> > #include <pthread.h> > +#include <posix/cb_lock.h> > > extern int __pse51_muxid; > > @@ -95,7 +96,7 @@ static void __pthread_cond_cleanup(void > c->count); > } > > -int __wrap_pthread_cond_wait(pthread_cond_t * cond, pthread_mutex_t * mutex) > +int __wrap_pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) > { > struct pse51_cond_cleanup_t c = { > .cond = (union __xeno_cond *)cond, > @@ -103,6 +104,9 @@ int __wrap_pthread_cond_wait(pthread_con > }; > int err, oldtype; > > + if (cb_try_read_lock(&c.mutex->shadow_mutex.lock, s)) > + return EINVAL; > + > pthread_cleanup_push(&__pthread_cond_cleanup, &c); > > pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype); > @@ -118,11 +122,15 @@ int __wrap_pthread_cond_wait(pthread_con > > pthread_cleanup_pop(0); > > - if (err) > + if (err) { > + cb_read_unlock(&c.mutex->shadow_mutex.lock, s); > return err; > + } > > __pthread_cond_cleanup(&c); > > + cb_read_unlock(&c.mutex->shadow_mutex.lock, s); > + > pthread_testcancel(); > > return 0; > @@ -138,6 +146,9 @@ int __wrap_pthread_cond_timedwait(pthrea > }; > int err, oldtype; > > + if (cb_try_read_lock(&c.mutex->shadow_mutex.lock, s)) > + return EINVAL; > + > pthread_cleanup_push(&__pthread_cond_cleanup, &c); > > pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype); > @@ -153,11 +164,15 @@ int __wrap_pthread_cond_timedwait(pthrea > > pthread_cleanup_pop(0); > > - if (err && err != ETIMEDOUT) > + if (err && err != ETIMEDOUT) { > + cb_read_unlock(&c.mutex->shadow_mutex.lock, s); > return err; > + } > > __pthread_cond_cleanup(&c); > > + cb_read_unlock(&c.mutex->shadow_mutex.lock, s); > + > pthread_testcancel(); > > return err; > Index: src/skins/posix/Makefile.am > =================================================================== > --- src/skins/posix/Makefile.am (revision 3738) > +++ src/skins/posix/Makefile.am (working copy) > @@ -2,6 +2,8 @@ includedir = $(prefix)/include/posix > > lib_LTLIBRARIES = libpthread_rt.la > > +CPPFLAGS+=-I$(top_srcdir)/ksrc/skins > + > libpthread_rt_la_LDFLAGS = -version-info 1:0:0 -lpthread > > libpthread_rt_la_SOURCES = \ > > -- Philippe. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support. 2008-05-18 16:42 ` Philippe Gerum @ 2008-05-18 17:05 ` Gilles Chanteperdrix 2008-05-18 17:29 ` Jan Kiszka 0 siblings, 1 reply; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-18 17:05 UTC (permalink / raw) To: rpm; +Cc: xenomai Philippe Gerum wrote: > Gilles Chanteperdrix wrote: > > Since binding of the semaphore heaps is now made by xeno_skin_bind, there is > > much less modifications in src/skins/posix/init.c. However, I had to do > > something really ugly: since binding the semaphore heaps by xeno_skin_bind > > requires calls to open, ioctl, mmap, close and munmap, I redefined these symbols > > to be the __real_ variants before including bind.h. > > Is there any upside to do this instead of simply calling the __real_* > placeholders, since we do already provide weak wrappers for those when the > linker's wrapping magic is not invoked? The point is that the wrappers and linker magic only take place for POSIX skins. Other skins have to call the genuine open, ioctl, mmap, close and munmap services. -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support. 2008-05-18 17:05 ` Gilles Chanteperdrix @ 2008-05-18 17:29 ` Jan Kiszka 2008-05-18 17:41 ` Gilles Chanteperdrix 0 siblings, 1 reply; 34+ messages in thread From: Jan Kiszka @ 2008-05-18 17:29 UTC (permalink / raw) To: Gilles Chanteperdrix; +Cc: xenomai [-- Attachment #1: Type: text/plain, Size: 1191 bytes --] Gilles Chanteperdrix wrote: > Philippe Gerum wrote: > > Gilles Chanteperdrix wrote: > > > Since binding of the semaphore heaps is now made by xeno_skin_bind, there is > > > much less modifications in src/skins/posix/init.c. However, I had to do > > > something really ugly: since binding the semaphore heaps by xeno_skin_bind > > > requires calls to open, ioctl, mmap, close and munmap, I redefined these symbols > > > to be the __real_ variants before including bind.h. > > > > Is there any upside to do this instead of simply calling the __real_* > > placeholders, since we do already provide weak wrappers for those when the > > linker's wrapping magic is not invoked? > > The point is that the wrappers and linker magic only take place for > POSIX skins. Other skins have to call the genuine open, ioctl, mmap, > close and munmap services. What about controlling the desired prefix for generic functions in bind.h via some #define that the caller has to/can set before including the header: #define POSIX_PREFIX __real_ #include <asm-generic/bits/bind.h> and there we would have: POSIX_PREFIX##open(...); Looks a bit cleaner to me. Jan [-- Attachment #2: OpenPGP digital signature --] [-- Type: application/pgp-signature, Size: 254 bytes --] ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support. 2008-05-18 17:29 ` Jan Kiszka @ 2008-05-18 17:41 ` Gilles Chanteperdrix 2008-05-18 17:52 ` Jan Kiszka 0 siblings, 1 reply; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-18 17:41 UTC (permalink / raw) To: Jan Kiszka; +Cc: xenomai Jan Kiszka wrote: > Gilles Chanteperdrix wrote: > > Philippe Gerum wrote: > > > Gilles Chanteperdrix wrote: > > > > Since binding of the semaphore heaps is now made by xeno_skin_bind, there is > > > > much less modifications in src/skins/posix/init.c. However, I had to do > > > > something really ugly: since binding the semaphore heaps by xeno_skin_bind > > > > requires calls to open, ioctl, mmap, close and munmap, I redefined these symbols > > > > to be the __real_ variants before including bind.h. > > > > > > Is there any upside to do this instead of simply calling the __real_* > > > placeholders, since we do already provide weak wrappers for those when the > > > linker's wrapping magic is not invoked? > > > > The point is that the wrappers and linker magic only take place for > > POSIX skins. Other skins have to call the genuine open, ioctl, mmap, > > close and munmap services. > > What about controlling the desired prefix for generic functions in > bind.h via some #define that the caller has to/can set before including > the header: > > #define POSIX_PREFIX __real_ > #include <asm-generic/bits/bind.h> > > and there we would have: > > POSIX_PREFIX##open(...); > > Looks a bit cleaner to me. Well, in this case we end up cluttering the code with the POSIX_PREFIX macro, even in the non posix case where no prefix is needed. -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support. 2008-05-18 17:41 ` Gilles Chanteperdrix @ 2008-05-18 17:52 ` Jan Kiszka 2008-05-18 18:09 ` Gilles Chanteperdrix 0 siblings, 1 reply; 34+ messages in thread From: Jan Kiszka @ 2008-05-18 17:52 UTC (permalink / raw) To: Gilles Chanteperdrix; +Cc: xenomai [-- Attachment #1: Type: text/plain, Size: 1780 bytes --] Gilles Chanteperdrix wrote: > Jan Kiszka wrote: > > Gilles Chanteperdrix wrote: > > > Philippe Gerum wrote: > > > > Gilles Chanteperdrix wrote: > > > > > Since binding of the semaphore heaps is now made by xeno_skin_bind, there is > > > > > much less modifications in src/skins/posix/init.c. However, I had to do > > > > > something really ugly: since binding the semaphore heaps by xeno_skin_bind > > > > > requires calls to open, ioctl, mmap, close and munmap, I redefined these symbols > > > > > to be the __real_ variants before including bind.h. > > > > > > > > Is there any upside to do this instead of simply calling the __real_* > > > > placeholders, since we do already provide weak wrappers for those when the > > > > linker's wrapping magic is not invoked? > > > > > > The point is that the wrappers and linker magic only take place for > > > POSIX skins. Other skins have to call the genuine open, ioctl, mmap, > > > close and munmap services. > > > > What about controlling the desired prefix for generic functions in > > bind.h via some #define that the caller has to/can set before including > > the header: > > > > #define POSIX_PREFIX __real_ > > #include <asm-generic/bits/bind.h> > > > > and there we would have: > > > > POSIX_PREFIX##open(...); > > > > Looks a bit cleaner to me. > > Well, in this case we end up cluttering the code with the POSIX_PREFIX > macro, even in the non posix case where no prefix is needed. Yes, but there are only few spots. The advantage of this strategy is that it is explicit in-place (ie. inside bind.h). That avoids potential collateral damage in the future when other services are added to that helper which shall not be wrapped. Jan [-- Attachment #2: OpenPGP digital signature --] [-- Type: application/pgp-signature, Size: 254 bytes --] ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support. 2008-05-18 17:52 ` Jan Kiszka @ 2008-05-18 18:09 ` Gilles Chanteperdrix 2008-05-18 18:56 ` Philippe Gerum 0 siblings, 1 reply; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-18 18:09 UTC (permalink / raw) To: Jan Kiszka; +Cc: xenomai Jan Kiszka wrote: > Gilles Chanteperdrix wrote: > > Jan Kiszka wrote: > > > Gilles Chanteperdrix wrote: > > > > Philippe Gerum wrote: > > > > > Gilles Chanteperdrix wrote: > > > > > > Since binding of the semaphore heaps is now made by xeno_skin_bind, there is > > > > > > much less modifications in src/skins/posix/init.c. However, I had to do > > > > > > something really ugly: since binding the semaphore heaps by xeno_skin_bind > > > > > > requires calls to open, ioctl, mmap, close and munmap, I redefined these symbols > > > > > > to be the __real_ variants before including bind.h. > > > > > > > > > > Is there any upside to do this instead of simply calling the __real_* > > > > > placeholders, since we do already provide weak wrappers for those when the > > > > > linker's wrapping magic is not invoked? > > > > > > > > The point is that the wrappers and linker magic only take place for > > > > POSIX skins. Other skins have to call the genuine open, ioctl, mmap, > > > > close and munmap services. > > > > > > What about controlling the desired prefix for generic functions in > > > bind.h via some #define that the caller has to/can set before including > > > the header: > > > > > > #define POSIX_PREFIX __real_ > > > #include <asm-generic/bits/bind.h> > > > > > > and there we would have: > > > > > > POSIX_PREFIX##open(...); > > > > > > Looks a bit cleaner to me. > > > > Well, in this case we end up cluttering the code with the POSIX_PREFIX > > macro, even in the non posix case where no prefix is needed. > > Yes, but there are only few spots. The advantage of this strategy is > that it is explicit in-place (ie. inside bind.h). That avoids potential > collateral damage in the future when other services are added to that > helper which shall not be wrapped. Actually, the only important call is open. Since once the file descriptor has been created with __real_open, all syscall wrappers will automatically fall back to the __real syscall variants. -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support. 2008-05-18 18:09 ` Gilles Chanteperdrix @ 2008-05-18 18:56 ` Philippe Gerum 2008-05-19 22:49 ` Gilles Chanteperdrix 0 siblings, 1 reply; 34+ messages in thread From: Philippe Gerum @ 2008-05-18 18:56 UTC (permalink / raw) To: Gilles Chanteperdrix; +Cc: Jan Kiszka, xenomai Gilles Chanteperdrix wrote: > Jan Kiszka wrote: > > Gilles Chanteperdrix wrote: > > > Jan Kiszka wrote: > > > > Gilles Chanteperdrix wrote: > > > > > Philippe Gerum wrote: > > > > > > Gilles Chanteperdrix wrote: > > > > > > > Since binding of the semaphore heaps is now made by xeno_skin_bind, there is > > > > > > > much less modifications in src/skins/posix/init.c. However, I had to do > > > > > > > something really ugly: since binding the semaphore heaps by xeno_skin_bind > > > > > > > requires calls to open, ioctl, mmap, close and munmap, I redefined these symbols > > > > > > > to be the __real_ variants before including bind.h. > > > > > > > > > > > > Is there any upside to do this instead of simply calling the __real_* > > > > > > placeholders, since we do already provide weak wrappers for those when the > > > > > > linker's wrapping magic is not invoked? > > > > > > > > > > The point is that the wrappers and linker magic only take place for > > > > > POSIX skins. Other skins have to call the genuine open, ioctl, mmap, > > > > > close and munmap services. > > > > > > > > What about controlling the desired prefix for generic functions in > > > > bind.h via some #define that the caller has to/can set before including > > > > the header: > > > > > > > > #define POSIX_PREFIX __real_ > > > > #include <asm-generic/bits/bind.h> > > > > > > > > and there we would have: > > > > > > > > POSIX_PREFIX##open(...); > > > > > > > > Looks a bit cleaner to me. > > > > > > Well, in this case we end up cluttering the code with the POSIX_PREFIX > > > macro, even in the non posix case where no prefix is needed. > > > > Yes, but there are only few spots. The advantage of this strategy is > > that it is explicit in-place (ie. inside bind.h). That avoids potential > > collateral damage in the future when other services are added to that > > helper which shall not be wrapped. > > Actually, the only important call is open. Since once the file > descriptor has been created with __real_open, all syscall wrappers will > automatically fall back to the __real syscall variants. > Then let's just provide __real_open() as a weak symbol in all libs; that's less error-prone that fiddling with the preprocessor. -- Philippe. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support. 2008-05-18 18:56 ` Philippe Gerum @ 2008-05-19 22:49 ` Gilles Chanteperdrix 2008-05-20 6:53 ` Philippe Gerum 0 siblings, 1 reply; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-19 22:49 UTC (permalink / raw) To: rpm; +Cc: Jan Kiszka, xenomai Philippe Gerum wrote: > Gilles Chanteperdrix wrote: > > Jan Kiszka wrote: > > > Gilles Chanteperdrix wrote: > > > > Jan Kiszka wrote: > > > > > Gilles Chanteperdrix wrote: > > > > > > Philippe Gerum wrote: > > > > > > > Gilles Chanteperdrix wrote: > > > > > > > > Since binding of the semaphore heaps is now made by xeno_skin_bind, there is > > > > > > > > much less modifications in src/skins/posix/init.c. However, I had to do > > > > > > > > something really ugly: since binding the semaphore heaps by xeno_skin_bind > > > > > > > > requires calls to open, ioctl, mmap, close and munmap, I redefined these symbols > > > > > > > > to be the __real_ variants before including bind.h. > > > > > > > > > > > > > > Is there any upside to do this instead of simply calling the __real_* > > > > > > > placeholders, since we do already provide weak wrappers for those when the > > > > > > > linker's wrapping magic is not invoked? > > > > > > > > > > > > The point is that the wrappers and linker magic only take place for > > > > > > POSIX skins. Other skins have to call the genuine open, ioctl, mmap, > > > > > > close and munmap services. > > > > > > > > > > What about controlling the desired prefix for generic functions in > > > > > bind.h via some #define that the caller has to/can set before including > > > > > the header: > > > > > > > > > > #define POSIX_PREFIX __real_ > > > > > #include <asm-generic/bits/bind.h> > > > > > > > > > > and there we would have: > > > > > > > > > > POSIX_PREFIX##open(...); > > > > > > > > > > Looks a bit cleaner to me. > > > > > > > > Well, in this case we end up cluttering the code with the POSIX_PREFIX > > > > macro, even in the non posix case where no prefix is needed. > > > > > > Yes, but there are only few spots. The advantage of this strategy is > > > that it is explicit in-place (ie. inside bind.h). That avoids potential > > > collateral damage in the future when other services are added to that > > > helper which shall not be wrapped. > > > > Actually, the only important call is open. Since once the file > > descriptor has been created with __real_open, all syscall wrappers will > > automatically fall back to the __real syscall variants. > > > > Then let's just provide __real_open() as a weak symbol in all libs; that's less > error-prone that fiddling with the preprocessor. For now, I kept a solution based on the preprocessor. If I remember correctly, the __real stuff needs to be in a separate object, this means that we cannot put __real_open definition in bind.h, we have to generate an open_wrapper.lo object and link every library with this object. Is this really what we want ? -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support. 2008-05-19 22:49 ` Gilles Chanteperdrix @ 2008-05-20 6:53 ` Philippe Gerum 2008-05-20 7:07 ` Jan Kiszka 0 siblings, 1 reply; 34+ messages in thread From: Philippe Gerum @ 2008-05-20 6:53 UTC (permalink / raw) To: Gilles Chanteperdrix; +Cc: Jan Kiszka, xenomai Gilles Chanteperdrix wrote: > Philippe Gerum wrote: > > Gilles Chanteperdrix wrote: > > > Jan Kiszka wrote: > > > > Gilles Chanteperdrix wrote: > > > > > Jan Kiszka wrote: > > > > > > Gilles Chanteperdrix wrote: > > > > > > > Philippe Gerum wrote: > > > > > > > > Gilles Chanteperdrix wrote: > > > > > > > > > Since binding of the semaphore heaps is now made by xeno_skin_bind, there is > > > > > > > > > much less modifications in src/skins/posix/init.c. However, I had to do > > > > > > > > > something really ugly: since binding the semaphore heaps by xeno_skin_bind > > > > > > > > > requires calls to open, ioctl, mmap, close and munmap, I redefined these symbols > > > > > > > > > to be the __real_ variants before including bind.h. > > > > > > > > > > > > > > > > Is there any upside to do this instead of simply calling the __real_* > > > > > > > > placeholders, since we do already provide weak wrappers for those when the > > > > > > > > linker's wrapping magic is not invoked? > > > > > > > > > > > > > > The point is that the wrappers and linker magic only take place for > > > > > > > POSIX skins. Other skins have to call the genuine open, ioctl, mmap, > > > > > > > close and munmap services. > > > > > > > > > > > > What about controlling the desired prefix for generic functions in > > > > > > bind.h via some #define that the caller has to/can set before including > > > > > > the header: > > > > > > > > > > > > #define POSIX_PREFIX __real_ > > > > > > #include <asm-generic/bits/bind.h> > > > > > > > > > > > > and there we would have: > > > > > > > > > > > > POSIX_PREFIX##open(...); > > > > > > > > > > > > Looks a bit cleaner to me. > > > > > > > > > > Well, in this case we end up cluttering the code with the POSIX_PREFIX > > > > > macro, even in the non posix case where no prefix is needed. > > > > > > > > Yes, but there are only few spots. The advantage of this strategy is > > > > that it is explicit in-place (ie. inside bind.h). That avoids potential > > > > collateral damage in the future when other services are added to that > > > > helper which shall not be wrapped. > > > > > > Actually, the only important call is open. Since once the file > > > descriptor has been created with __real_open, all syscall wrappers will > > > automatically fall back to the __real syscall variants. > > > > > > > Then let's just provide __real_open() as a weak symbol in all libs; that's less > > error-prone that fiddling with the preprocessor. > > For now, I kept a solution based on the preprocessor. If I remember > correctly, the __real stuff needs to be in a separate object, this > means that we cannot put __real_open definition in bind.h, we have to > generate an open_wrapper.lo object and link every library with this > object. Is this really what we want ? > bind.h is meant to be included exclusively from init.c files. So yes, as far as possible, we don't want to mess with the preprocessor. -- Philippe. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support. 2008-05-20 6:53 ` Philippe Gerum @ 2008-05-20 7:07 ` Jan Kiszka 2008-05-20 7:23 ` Gilles Chanteperdrix 0 siblings, 1 reply; 34+ messages in thread From: Jan Kiszka @ 2008-05-20 7:07 UTC (permalink / raw) To: rpm; +Cc: xenomai [-- Attachment #1: Type: text/plain, Size: 3497 bytes --] Philippe Gerum wrote: > Gilles Chanteperdrix wrote: >> Philippe Gerum wrote: >> > Gilles Chanteperdrix wrote: >> > > Jan Kiszka wrote: >> > > > Gilles Chanteperdrix wrote: >> > > > > Jan Kiszka wrote: >> > > > > > Gilles Chanteperdrix wrote: >> > > > > > > Philippe Gerum wrote: >> > > > > > > > Gilles Chanteperdrix wrote: >> > > > > > > > > Since binding of the semaphore heaps is now made by xeno_skin_bind, there is >> > > > > > > > > much less modifications in src/skins/posix/init.c. However, I had to do >> > > > > > > > > something really ugly: since binding the semaphore heaps by xeno_skin_bind >> > > > > > > > > requires calls to open, ioctl, mmap, close and munmap, I redefined these symbols >> > > > > > > > > to be the __real_ variants before including bind.h. >> > > > > > > > >> > > > > > > > Is there any upside to do this instead of simply calling the __real_* >> > > > > > > > placeholders, since we do already provide weak wrappers for those when the >> > > > > > > > linker's wrapping magic is not invoked? >> > > > > > > >> > > > > > > The point is that the wrappers and linker magic only take place for >> > > > > > > POSIX skins. Other skins have to call the genuine open, ioctl, mmap, >> > > > > > > close and munmap services. >> > > > > > >> > > > > > What about controlling the desired prefix for generic functions in >> > > > > > bind.h via some #define that the caller has to/can set before including >> > > > > > the header: >> > > > > > >> > > > > > #define POSIX_PREFIX __real_ >> > > > > > #include <asm-generic/bits/bind.h> >> > > > > > >> > > > > > and there we would have: >> > > > > > >> > > > > > POSIX_PREFIX##open(...); >> > > > > > >> > > > > > Looks a bit cleaner to me. >> > > > > >> > > > > Well, in this case we end up cluttering the code with the POSIX_PREFIX >> > > > > macro, even in the non posix case where no prefix is needed. >> > > > >> > > > Yes, but there are only few spots. The advantage of this strategy is >> > > > that it is explicit in-place (ie. inside bind.h). That avoids potential >> > > > collateral damage in the future when other services are added to that >> > > > helper which shall not be wrapped. >> > > >> > > Actually, the only important call is open. Since once the file >> > > descriptor has been created with __real_open, all syscall wrappers will >> > > automatically fall back to the __real syscall variants. >> > > >> > >> > Then let's just provide __real_open() as a weak symbol in all libs; that's less >> > error-prone that fiddling with the preprocessor. >> >> For now, I kept a solution based on the preprocessor. If I remember >> correctly, the __real stuff needs to be in a separate object, this >> means that we cannot put __real_open definition in bind.h, we have to >> generate an open_wrapper.lo object and link every library with this >> object. Is this really what we want ? >> > > bind.h is meant to be included exclusively from init.c files. So yes, as far as > possible, we don't want to mess with the preprocessor. Then better let the caller decide which version to call. A simple argument to xeno_bind_skin can be passed through to map_sem_heap and define there if open or __real_open is used. As the functions are inlined, we shouldn't see the other symbol after the compilation. Jan [-- Attachment #2: OpenPGP digital signature --] [-- Type: application/pgp-signature, Size: 254 bytes --] ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support. 2008-05-20 7:07 ` Jan Kiszka @ 2008-05-20 7:23 ` Gilles Chanteperdrix 0 siblings, 0 replies; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-20 7:23 UTC (permalink / raw) To: Jan Kiszka; +Cc: xenomai On Tue, May 20, 2008 at 9:07 AM, Jan Kiszka <jan.kiszka@domain.hid> wrote: > Philippe Gerum wrote: >> Gilles Chanteperdrix wrote: >>> Philippe Gerum wrote: >>> > Gilles Chanteperdrix wrote: >>> > > Jan Kiszka wrote: >>> > > > Gilles Chanteperdrix wrote: >>> > > > > Jan Kiszka wrote: >>> > > > > > Gilles Chanteperdrix wrote: >>> > > > > > > Philippe Gerum wrote: >>> > > > > > > > Gilles Chanteperdrix wrote: >>> > > > > > > > > Since binding of the semaphore heaps is now made by xeno_skin_bind, there is >>> > > > > > > > > much less modifications in src/skins/posix/init.c. However, I had to do >>> > > > > > > > > something really ugly: since binding the semaphore heaps by xeno_skin_bind >>> > > > > > > > > requires calls to open, ioctl, mmap, close and munmap, I redefined these symbols >>> > > > > > > > > to be the __real_ variants before including bind.h. >>> > > > > > > > >>> > > > > > > > Is there any upside to do this instead of simply calling the __real_* >>> > > > > > > > placeholders, since we do already provide weak wrappers for those when the >>> > > > > > > > linker's wrapping magic is not invoked? >>> > > > > > > >>> > > > > > > The point is that the wrappers and linker magic only take place for >>> > > > > > > POSIX skins. Other skins have to call the genuine open, ioctl, mmap, >>> > > > > > > close and munmap services. >>> > > > > > >>> > > > > > What about controlling the desired prefix for generic functions in >>> > > > > > bind.h via some #define that the caller has to/can set before including >>> > > > > > the header: >>> > > > > > >>> > > > > > #define POSIX_PREFIX __real_ >>> > > > > > #include <asm-generic/bits/bind.h> >>> > > > > > >>> > > > > > and there we would have: >>> > > > > > >>> > > > > > POSIX_PREFIX##open(...); >>> > > > > > >>> > > > > > Looks a bit cleaner to me. >>> > > > > >>> > > > > Well, in this case we end up cluttering the code with the POSIX_PREFIX >>> > > > > macro, even in the non posix case where no prefix is needed. >>> > > > >>> > > > Yes, but there are only few spots. The advantage of this strategy is >>> > > > that it is explicit in-place (ie. inside bind.h). That avoids potential >>> > > > collateral damage in the future when other services are added to that >>> > > > helper which shall not be wrapped. >>> > > >>> > > Actually, the only important call is open. Since once the file >>> > > descriptor has been created with __real_open, all syscall wrappers will >>> > > automatically fall back to the __real syscall variants. >>> > > >>> > >>> > Then let's just provide __real_open() as a weak symbol in all libs; that's less >>> > error-prone that fiddling with the preprocessor. >>> >>> For now, I kept a solution based on the preprocessor. If I remember >>> correctly, the __real stuff needs to be in a separate object, this >>> means that we cannot put __real_open definition in bind.h, we have to >>> generate an open_wrapper.lo object and link every library with this >>> object. Is this really what we want ? >>> >> >> bind.h is meant to be included exclusively from init.c files. So yes, as far as >> possible, we don't want to mess with the preprocessor. > > Then better let the caller decide which version to call. A simple > argument to xeno_bind_skin can be passed through to map_sem_heap and > define there if open or __real_open is used. As the functions are > inlined, we shouldn't see the other symbol after the compilation. Except the day when would compile without optimization... I will implement the open_wrapper.lo solution. -- Gilles ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin 2008-05-02 22:35 ` [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin Gilles Chanteperdrix 2008-05-02 22:36 ` [Xenomai-core] [Patch 6/7] Re-implementation of mutexes, kernel-space support Gilles Chanteperdrix @ 2008-05-18 16:40 ` Philippe Gerum 2008-05-18 17:21 ` Gilles Chanteperdrix 2008-05-18 18:37 ` Gilles Chanteperdrix 1 sibling, 2 replies; 34+ messages in thread From: Philippe Gerum @ 2008-05-18 16:40 UTC (permalink / raw) To: Gilles Chanteperdrix; +Cc: xenomai Gilles Chanteperdrix wrote: > The two syscalls defined in the posix skin now moved to the sys skin, they are > used in user-space by include/asm-generic/bits/bind.h and the new header > include/asm-generic/bits/current.h. The global and process-specific shared heaps > are now part of this patch. > Is there any reason why the nucleus should not implement a full-fledged "RT futex" support, instead of a toolbox to build them? I'm concerned by skins reinventing their own wheel uselessly to get to the same point at the end of the day; e.g. cb_lock ops seem to me fairly generic when it comes to handling futexes, so I would move them upstream one level more. In that respect, talking about "semaphore heaps" at nucleus level looks a bit of a misnomer: if we mostly bring a service to map non-cacheable memory to user-space, then we don't actually provide semaphore support. > --- > include/asm-generic/bits/Makefile.am | 1 > include/asm-generic/bits/bind.h | 121 +++++++++++++++++++++++++++++++++++ > include/asm-generic/bits/current.h | 14 ++++ > include/asm-generic/syscall.h | 2 > include/nucleus/Makefile.am | 1 > include/nucleus/sys_ppd.h | 37 ++++++++++ > include/posix/syscall.h | 1 > ksrc/nucleus/Kconfig | 25 +++++++ > ksrc/nucleus/module.c | 19 ++++- > ksrc/nucleus/shadow.c | 103 ++++++++++++++++++++++++++++- > src/skins/posix/thread.c | 4 + > 11 files changed, 323 insertions(+), 5 deletions(-) > > Index: include/asm-generic/syscall.h > =================================================================== > --- include/asm-generic/syscall.h (revision 3738) > +++ include/asm-generic/syscall.h (working copy) > @@ -30,6 +30,8 @@ > #define __xn_sys_info 4 /* xnshadow_get_info(muxid,&info) */ > #define __xn_sys_arch 5 /* r = xnarch_local_syscall(args) */ > #define __xn_sys_trace 6 /* r = xntrace_xxx(...) */ > +#define __xn_sys_sem_heap 7 > +#define __xn_sys_current 8 > > #define XENOMAI_LINUX_DOMAIN 0 > #define XENOMAI_XENO_DOMAIN 1 > Index: ksrc/nucleus/Kconfig > =================================================================== > --- ksrc/nucleus/Kconfig (revision 3738) > +++ ksrc/nucleus/Kconfig (working copy) > @@ -158,6 +158,31 @@ config XENO_OPT_SYS_STACKPOOLSZ > default 0 > endif > > +config XENO_OPT_SEM_HEAPSZ > + int "Size of private semaphores heap (Kb)" > + default 12 > + help > + > + Xenomai implementation of user-space semaphores relies on heaps > + shared between kernel and user-space. This configuration entry > + allow to set the size of the heap used for private semaphores. > + > + Note that each semaphore will allocate 4 or 8 bytes of memory, It would be nice to tell the folks why such difference (32/64bit arch?) > + so, the default of 12 Kb allows creating many semaphores. > + > +config XENO_OPT_GLOBAL_SEM_HEAPSZ > + int "Size of global semaphores heap (Kb)" > + default 12 > + help > + > + Xenomai implementation of user-space semaphores relies on heaps > + shared between kernel and user-space. This configuration entry > + allow to set the size of the heap used for semaphores shared > + between several processes. > + > + Note that each semaphore will allocate 4 or 8 bytes of memory, > + so, the default of 12 Kb allows creating many semaphores. > + > config XENO_OPT_STATS > bool "Statistics collection" > depends on PROC_FS > Index: ksrc/nucleus/module.c > =================================================================== > --- ksrc/nucleus/module.c (revision 3738) > +++ ksrc/nucleus/module.c (working copy) > @@ -28,6 +28,7 @@ > #include <nucleus/timer.h> > #include <nucleus/heap.h> > #include <nucleus/version.h> > +#include <nucleus/sys_ppd.h> > #ifdef CONFIG_XENO_OPT_PIPE > #include <nucleus/pipe.h> > #endif /* CONFIG_XENO_OPT_PIPE */ > @@ -50,6 +51,8 @@ u_long xnmod_sysheap_size; > > int xeno_nucleus_status = -EINVAL; > > +struct xnsys_ppd __xnsys_global_ppd; > + > void xnmod_alloc_glinks(xnqueue_t *freehq) > { > xngholder_t *sholder, *eholder; > @@ -1156,6 +1159,14 @@ int __init __xeno_sys_init(void) > if (err) > goto fail; > > + err = xnheap_init_mapped(&__xnsys_global_ppd.sem_heap, > + CONFIG_XENO_OPT_GLOBAL_SEM_HEAPSZ * 1024, > + XNARCH_SHARED_HEAP_FLAGS ?: > + (CONFIG_XENO_OPT_GLOBAL_SEM_HEAPSZ <= 128 > + ? GFP_USER : 0)); > + if (err) > + goto cleanup_arch; > + > #ifdef __KERNEL__ > #ifdef CONFIG_PROC_FS > xnpod_init_proc(); > @@ -1167,7 +1178,7 @@ int __init __xeno_sys_init(void) > err = xnpipe_mount(); > > if (err) > - goto cleanup_arch; > + goto cleanup_proc; > #endif /* CONFIG_XENO_OPT_PIPE */ > > #ifdef CONFIG_XENO_OPT_PERVASIVE > @@ -1207,7 +1218,7 @@ int __init __xeno_sys_init(void) > #ifdef CONFIG_XENO_OPT_PIPE > xnpipe_umount(); > > - cleanup_arch: > + cleanup_proc: > > #endif /* CONFIG_XENO_OPT_PIPE */ > > @@ -1215,6 +1226,8 @@ int __init __xeno_sys_init(void) > xnpod_delete_proc(); > #endif /* CONFIG_PROC_FS */ > > + cleanup_arch: > + > xnarch_exit(); > > #endif /* __KERNEL__ */ > @@ -1254,6 +1267,8 @@ void __exit __xeno_sys_exit(void) > #endif /* CONFIG_XENO_OPT_PIPE */ > #endif /* __KERNEL__ */ > > + xnheap_destroy_mapped(&__xnsys_global_ppd.sem_heap); > + > if (nkmsgbuf) > xnarch_free_host_mem(nkmsgbuf, XNPOD_FATAL_BUFSZ); > > Index: ksrc/nucleus/shadow.c > =================================================================== > --- ksrc/nucleus/shadow.c (revision 3738) > +++ ksrc/nucleus/shadow.c (working copy) > @@ -51,6 +51,7 @@ > #include <nucleus/ppd.h> > #include <nucleus/trace.h> > #include <nucleus/stat.h> > +#include <nucleus/sys_ppd.h> > #include <asm/xenomai/features.h> > #include <asm/xenomai/syscall.h> > #include <asm/xenomai/bits/shadow.h> > @@ -1558,11 +1559,11 @@ static void stringify_feature_set(u_long > > static int xnshadow_sys_bind(struct pt_regs *regs) > { > + xnshadow_ppd_t *ppd = NULL, *sys_ppd = NULL; > unsigned magic = __xn_reg_arg1(regs); > u_long featdep = __xn_reg_arg2(regs); > u_long abirev = __xn_reg_arg3(regs); > u_long infarg = __xn_reg_arg4(regs); > - xnshadow_ppd_t *ppd = NULL; > xnfeatinfo_t finfo; > u_long featmis; > int muxid, err; > @@ -1636,6 +1637,36 @@ static int xnshadow_sys_bind(struct pt_r > earlier than that, do not refer to nkpod until the latter had a > chance to call xnpod_init(). */ > > + xnlock_get_irqsave(&nklock, s); > + sys_ppd = ppd_lookup(0, current->mm); > + xnlock_put_irqrestore(&nklock, s); > + > + if (sys_ppd) > + goto muxid_eventcb; > + > + sys_ppd = (xnshadow_ppd_t *) muxtable[0].props->eventcb(XNSHADOW_CLIENT_ATTACH, > + current); > + > + if (IS_ERR(sys_ppd)) { > + err = PTR_ERR(sys_ppd); > + goto fail; > + } > + > + if (!sys_ppd) > + goto muxid_eventcb; > + > + > + sys_ppd->key.muxid = 0; > + sys_ppd->key.mm = current->mm; > + > + if (ppd_insert(sys_ppd) == -EBUSY) { > + /* In case of concurrent binding (which can not happen with > + Xenomai libraries), detach right away the second ppd. */ > + muxtable[0].props->eventcb(XNSHADOW_CLIENT_DETACH, sys_ppd); > + sys_ppd = NULL; > + } > + > + muxid_eventcb: > if (!muxtable[muxid].props->eventcb) > goto eventcb_done; > > @@ -1652,7 +1683,7 @@ static int xnshadow_sys_bind(struct pt_r > > if (IS_ERR(ppd)) { > err = PTR_ERR(ppd); > - goto fail; > + goto fail_destroy_sys_ppd; > } > > if (!ppd) > @@ -1689,6 +1720,11 @@ static int xnshadow_sys_bind(struct pt_r > > err = -ENOSYS; > > + fail_destroy_sys_ppd: > + if (sys_ppd) { > + ppd_remove(sys_ppd); > + muxtable[0].props->eventcb(XNSHADOW_CLIENT_DETACH, sys_ppd); > + } > fail: > if (!xnarch_atomic_get(&muxtable[muxid].refcnt)) > xnarch_atomic_dec(&muxtable[muxid].refcnt); > @@ -1856,6 +1892,32 @@ static int xnshadow_sys_trace(struct pt_ > return err; > } > > +struct heap_info { > + xnheap_t *addr; > + unsigned size; > +}; > + > +static int xnshadow_sys_sem_heap(struct pt_regs *regs) > +{ > + struct heap_info hinfo, __user *us_hinfo; > + unsigned global; > + > + global = __xn_reg_arg2(regs); > + us_hinfo = (struct heap_info __user *) __xn_reg_arg1(regs); > + hinfo.addr = &xnsys_ppd_get(global)->sem_heap; > + hinfo.size = xnheap_extentsize(hinfo.addr); > + > + return __xn_safe_copy_to_user(us_hinfo, &hinfo, sizeof(*us_hinfo)); > +} > + > +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); > + > + return __xn_safe_copy_to_user(us_current, &cur, sizeof(*us_current)); > +} > + > static xnsysent_t __systab[] = { > [__xn_sys_migrate] = {&xnshadow_sys_migrate, __xn_exec_current}, > [__xn_sys_arch] = {&xnshadow_sys_arch, __xn_exec_any}, > @@ -1864,15 +1926,50 @@ static xnsysent_t __systab[] = { > [__xn_sys_completion] = {&xnshadow_sys_completion, __xn_exec_lostage}, > [__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}, > + [__xn_sys_current] = {&xnshadow_sys_current, __xn_exec_any}, > }; > > +static void *xnshadow_sys_event(int event, void *data) > +{ > + struct xnsys_ppd *p; > + int err; > + > + switch(event) { > + case XNSHADOW_CLIENT_ATTACH: > + p = (struct xnsys_ppd *) xnarch_alloc_host_mem(sizeof(*p)); > + if (!p) > + return ERR_PTR(-ENOMEM); > + > + err = xnheap_init_mapped(&p->sem_heap, > + CONFIG_XENO_OPT_SEM_HEAPSZ * 1024, > + XNARCH_SHARED_HEAP_FLAGS ?: > + (CONFIG_XENO_OPT_SEM_HEAPSZ <= 128 > + ? GFP_USER : 0)); > + if (err) { > + xnarch_free_host_mem(p, sizeof(*p)); > + return ERR_PTR(err); > + } > + > + return &p->ppd; > + > + case XNSHADOW_CLIENT_DETACH: > + p = ppd2sys((xnshadow_ppd_t *) data); > + > + xnheap_destroy_mapped(&p->sem_heap); > + > + return NULL; > + } > + > + return ERR_PTR(-EINVAL); > +} > > static struct xnskin_props __props = { > .name = "sys", > .magic = 0x434F5245, > .nrcalls = sizeof(__systab) / sizeof(__systab[0]), > .systab = __systab, > - .eventcb = NULL, > + .eventcb = xnshadow_sys_event, > .timebasep = NULL, > .module = NULL > }; > Index: include/posix/syscall.h > =================================================================== > --- include/posix/syscall.h (revision 3738) > +++ include/posix/syscall.h (working copy) > @@ -46,6 +46,7 @@ > #define __pse51_mutex_lock 20 > #define __pse51_mutex_timedlock 21 > #define __pse51_mutex_trylock 22 > +#define __pse51_check_init __pse51_mutex_trylock > #define __pse51_mutex_unlock 23 > #define __pse51_cond_init 24 > #define __pse51_cond_destroy 25 > Index: src/skins/posix/thread.c > =================================================================== > --- src/skins/posix/thread.c (revision 3738) > +++ src/skins/posix/thread.c (working copy) > @@ -24,6 +24,7 @@ > #include <sys/types.h> > #include <semaphore.h> > #include <posix/syscall.h> > +#include <asm-generic/bits/current.h> > > extern int __pse51_muxid; > > @@ -56,6 +57,7 @@ int __wrap_pthread_setschedparam(pthread > > if (!err && promoted) { > old_sigharden_handler = signal(SIGHARDEN, &__pthread_sigharden_handler); > + xeno_set_current(); > if (policy != SCHED_OTHER) > XENOMAI_SYSCALL1(__xn_sys_migrate, XENOMAI_XENO_DOMAIN); > } > @@ -132,6 +134,8 @@ static void *__pthread_trampoline(void * > start = iargs->start; > cookie = iargs->arg; > > + xeno_set_current(); > + > __real_sem_post(&iargs->sync); > > if (!err) { > Index: include/asm-generic/bits/current.h > =================================================================== > --- include/asm-generic/bits/current.h (revision 0) > +++ include/asm-generic/bits/current.h (revision 0) > @@ -0,0 +1,14 @@ > +#ifndef _XENO_ASM_GENERIC_CURRENT_H > +#define _XENO_ASM_GENERIC_CURRENT_H > + > +#include <pthread.h> > + > +extern pthread_key_t xeno_current_key; > + > +extern void xeno_set_current(void); > + > +static inline void *xeno_get_current(void) > +{ > + return pthread_getspecific(xeno_current_key); > +} > +#endif /* _XENO_ASM_GENERIC_CURRENT_H */ > Index: include/asm-generic/bits/Makefile.am > =================================================================== > --- include/asm-generic/bits/Makefile.am (revision 3738) > +++ include/asm-generic/bits/Makefile.am (working copy) > @@ -2,6 +2,7 @@ includesubdir = $(includedir)/asm-generi > > includesub_HEADERS = \ > bind.h \ > + current.h \ > heap.h \ > intr.h \ > mlock_alert.h \ > Index: include/nucleus/sys_ppd.h > =================================================================== > --- include/nucleus/sys_ppd.h (revision 0) > +++ include/nucleus/sys_ppd.h (revision 0) > @@ -0,0 +1,37 @@ > +#ifndef _XENO_NUCLEUS_SYS_PPD_H > +#define _XENO_NUCLEUS_SYS_PPD_H > + > +#include <nucleus/ppd.h> > +#include <nucleus/heap.h> > + > +struct xnsys_ppd { > + xnshadow_ppd_t ppd; > + xnheap_t sem_heap; > + > +#define ppd2sys(addr) container_of(addr, struct xnsys_ppd, ppd) > +}; > + > +extern struct xnsys_ppd __xnsys_global_ppd; > + > +#ifdef CONFIG_XENO_OPT_PERVASIVE > + > +static inline struct xnsys_ppd *xnsys_ppd_get(int global) > +{ > + xnshadow_ppd_t *ppd; > + > + if (global || !(ppd = xnshadow_ppd_get(0))) > + return &__xnsys_global_ppd; > + > + return ppd2sys(ppd); > +} > + > +#else /* !CONFIG_XENO_OPT_PERVASIVE */ > + > +static inline struct xnsys_ppd *xnsys_ppd_get(int global) > +{ > + return &__xnsys_global_ppd; > +} > + > +#endif /* !CONFIG_XENO_OPT_PERVASIVE */ > + > +#endif /* _XENO_NUCLEUS_SYS_PPD_H */ > Index: include/nucleus/Makefile.am > =================================================================== > --- include/nucleus/Makefile.am (revision 3738) > +++ include/nucleus/Makefile.am (working copy) > @@ -20,6 +20,7 @@ includesub_HEADERS = \ > stat.h \ > synch.h \ > system.h \ > + sys_ppd.h \ > thread.h \ > timebase.h \ > timer.h \ > Index: include/asm-generic/bits/bind.h > =================================================================== > --- include/asm-generic/bits/bind.h (revision 3738) > +++ include/asm-generic/bits/bind.h (working copy) > @@ -6,10 +6,89 @@ > #include <string.h> > #include <errno.h> > #include <signal.h> > +#include <pthread.h> > +#include <sys/ioctl.h> > #include <asm/xenomai/syscall.h> > > +__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); > + pthread_setspecific(xeno_current_key, kthread_cb); > +} > + > +static void init_current_key(void) > +{ > + int err = pthread_key_create(&xeno_current_key, NULL); > + if (err) { > + fprintf(stderr, "Xenomai: error creating TSD key: %s\n", > + strerror(err)); > + exit(1); > + } > +} > + > +__attribute__ ((weak)) > +unsigned long xeno_sem_heap[2] = { 0, 0 }; > + > void xeno_handle_mlock_alert(int sig); > > +static void *map_sem_heap(unsigned shared) > +{ > + struct heap_info { > + void *addr; > + unsigned size; > + } hinfo; > + int fd, err; > + > + fd = open("/dev/rtheap", O_RDWR, 0); > + if (fd < 0) { > + fprintf(stderr, "Xenomai: open: %m\n"); > + return MAP_FAILED; > + } > + > + err = XENOMAI_SYSCALL2(__xn_sys_sem_heap, &hinfo, shared); > + if (err < 0) { > + fprintf(stderr, "Xenomai: sys_sem_heap: %m\n"); > + return MAP_FAILED; > + } > + > + err = ioctl(fd, 0, hinfo.addr); > + if (err < 0) { > + fprintf(stderr, "Xenomai: ioctl: %m\n"); > + return MAP_FAILED; > + } > + > + hinfo.addr = mmap(NULL, hinfo.size, > + PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); > + close(fd); > + > + return hinfo.addr; > +} > + > +static void unmap_sem_heap(unsigned long heap_addr, unsigned shared) > +{ > + struct heap_info { > + void *addr; > + unsigned size; > + } hinfo; > + int err; > + > + err = XENOMAI_SYSCALL2(__xn_sys_sem_heap, &hinfo, shared); > + if (err < 0) { > + fprintf(stderr, "Xenomai: sys_sem_heap: %m\n"); > + return; > + } > + > + munmap((void *) heap_addr, hinfo.size); > +} > + > + > static inline int > xeno_bind_skin(unsigned skin_magic, const char *skin, const char *module) > { > @@ -62,6 +141,27 @@ 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); > + > + /* 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); > + xeno_sem_heap[0] = (unsigned long) map_sem_heap(0); > + if (xeno_sem_heap[0] == (unsigned long) MAP_FAILED) { > + perror("Xenomai: mmap(local sem heap)"); > + exit(EXIT_FAILURE); > + } > + > + /* Even if we forked the global semaphore heap did not change, no need > + to map it anew */ > + if (!xeno_sem_heap[1]) { > + xeno_sem_heap[1] = (unsigned long) map_sem_heap(1); > + if (xeno_sem_heap[1] == (unsigned long) MAP_FAILED) { > + perror("Xenomai: mmap(global sem heap)"); > + exit(EXIT_FAILURE); > + } > + } > + > return muxid; > } > > @@ -105,6 +205,27 @@ 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); > + > + /* 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); > + xeno_sem_heap[0] = (unsigned long) map_sem_heap(0); > + if (xeno_sem_heap[0] == (unsigned long) MAP_FAILED) { > + perror("Xenomai: mmap(local sem heap)"); > + exit(EXIT_FAILURE); > + } > + > + /* Even if we forked the global semaphore heap did not change, no need > + to map it anew */ > + if (!xeno_sem_heap[1]) { > + xeno_sem_heap[1] = (unsigned long) map_sem_heap(1); > + if (xeno_sem_heap[1] == (unsigned long) MAP_FAILED) { > + perror("Xenomai: mmap(global sem heap)"); > + exit(EXIT_FAILURE); > + } > + } > + > return muxid; > } > > -- Philippe. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin 2008-05-18 16:40 ` [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin Philippe Gerum @ 2008-05-18 17:21 ` Gilles Chanteperdrix 2008-05-18 18:37 ` Gilles Chanteperdrix 1 sibling, 0 replies; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-18 17:21 UTC (permalink / raw) To: rpm; +Cc: xenomai Philippe Gerum wrote: > Gilles Chanteperdrix wrote: > > The two syscalls defined in the posix skin now moved to the sys skin, they are > > used in user-space by include/asm-generic/bits/bind.h and the new header > > include/asm-generic/bits/current.h. The global and process-specific shared heaps > > are now part of this patch. > > > > Is there any reason why the nucleus should not implement a full-fledged "RT > futex" support, instead of a toolbox to build them? I'm concerned by skins > reinventing their own wheel uselessly to get to the same point at the end of the > day; e.g. cb_lock ops seem to me fairly generic when it comes to handling > futexes, so I would move them upstream one level more. > First of all, because I do not know much what a futex is, but from my point of view it has very much to do with making threads wait in kernel-space for a user-space change. By using kernel/user shared heaps, we seem to be far from these considerations. Now for the implementation of user-space mutexes per-se, apart from the xnarch_atomic_ operations, I think every skin will have its own tradeoffs. For instance, the "cb_lock" thing is itself a tradeoff, it sacrifices a bit of performance by making a mutex lock operation use three atomic operations instead of only one for the sake of safely getting a correct value of the mapped memory pointer. Besides, it works well with the posix skin, because the posix specification allows pthread_mutex_destroy to return an error if a mutex is currently in use. Currently, the native skin mutex destruction operation is successful even if the mutex is currently in use (the owner does not get any notification, simply its unlock operation will fail, and waiters receive an -EIDRM error). So, I would guess the native skin will have to use something else than cb_lock. > In that respect, talking about "semaphore heaps" at nucleus level looks a bit of > a misnomer: if we mostly bring a service to map non-cacheable memory to > user-space, then we don't actually provide semaphore support. It was only a name making clear to the user what the heaps will be used for... I imagine people having to configure yet another heap size in kernel configuration and wondering what this heap will be used for. -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin 2008-05-18 16:40 ` [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin Philippe Gerum 2008-05-18 17:21 ` Gilles Chanteperdrix @ 2008-05-18 18:37 ` Gilles Chanteperdrix 2008-05-18 19:10 ` Philippe Gerum 1 sibling, 1 reply; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-18 18:37 UTC (permalink / raw) To: rpm; +Cc: xenomai Philippe Gerum wrote: > Gilles Chanteperdrix wrote: > > The two syscalls defined in the posix skin now moved to the sys skin, they are > > used in user-space by include/asm-generic/bits/bind.h and the new header > > include/asm-generic/bits/current.h. The global and process-specific shared heaps > > are now part of this patch. > > > > Is there any reason why the nucleus should not implement a full-fledged "RT > futex" support, instead of a toolbox to build them? I'm concerned by skins > reinventing their own wheel uselessly to get to the same point at the end of the > day; e.g. cb_lock ops seem to me fairly generic when it comes to handling > futexes, so I would move them upstream one level more. > > In that respect, talking about "semaphore heaps" at nucleus level looks a bit of > a misnomer: if we mostly bring a service to map non-cacheable memory to > user-space, then we don't actually provide semaphore support. If I understand correctly, a futex is, in xenomai terms, a way to associate a user-space address, with an xnsynch object. I feel this would complicate things: currently, the way I implemented user-space mutexes for the posix skin kept the old association between the user-space mutex, and its kernel-space companion, also used by kernel-space operations. -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin 2008-05-18 18:37 ` Gilles Chanteperdrix @ 2008-05-18 19:10 ` Philippe Gerum 2008-05-18 19:38 ` Gilles Chanteperdrix 0 siblings, 1 reply; 34+ messages in thread From: Philippe Gerum @ 2008-05-18 19:10 UTC (permalink / raw) To: Gilles Chanteperdrix; +Cc: xenomai Gilles Chanteperdrix wrote: > Philippe Gerum wrote: > > Gilles Chanteperdrix wrote: > > > The two syscalls defined in the posix skin now moved to the sys skin, they are > > > used in user-space by include/asm-generic/bits/bind.h and the new header > > > include/asm-generic/bits/current.h. The global and process-specific shared heaps > > > are now part of this patch. > > > > > > > Is there any reason why the nucleus should not implement a full-fledged "RT > > futex" support, instead of a toolbox to build them? I'm concerned by skins > > reinventing their own wheel uselessly to get to the same point at the end of the > > day; e.g. cb_lock ops seem to me fairly generic when it comes to handling > > futexes, so I would move them upstream one level more. > > > > In that respect, talking about "semaphore heaps" at nucleus level looks a bit of > > a misnomer: if we mostly bring a service to map non-cacheable memory to > > user-space, then we don't actually provide semaphore support. > > If I understand correctly, a futex is, in xenomai terms, a way to > associate a user-space address, with an xnsynch object. I would specialize it more actually so that it really resembles the vanilla futex support, i.e. a basic object implementing the required operations to provide mutually exclusive access, working on a pinned memory area shared between kernel and userland. AFAICS, the current patchset implements the pinned memory support in the nucleus, but not the operations, which remain a per-skin issue. I feel this > would complicate things: currently, the way I implemented user-space > mutexes for the posix skin kept the old association between the > user-space mutex, and its kernel-space companion, also used by > kernel-space operations. > My concern boils down to: how much of the POSIX implementation, beyond the cb_lock stuff, would have to be duplicated to get the same support ported to, say the VxWorks semM services? -- Philippe. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin 2008-05-18 19:10 ` Philippe Gerum @ 2008-05-18 19:38 ` Gilles Chanteperdrix 2008-05-18 21:52 ` Philippe Gerum 0 siblings, 1 reply; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-18 19:38 UTC (permalink / raw) To: rpm; +Cc: xenomai Philippe Gerum wrote: > Gilles Chanteperdrix wrote: > > Philippe Gerum wrote: > > > Gilles Chanteperdrix wrote: > > > > The two syscalls defined in the posix skin now moved to the sys skin, they are > > > > used in user-space by include/asm-generic/bits/bind.h and the new header > > > > include/asm-generic/bits/current.h. The global and process-specific shared heaps > > > > are now part of this patch. > > > > > > > > > > Is there any reason why the nucleus should not implement a full-fledged "RT > > > futex" support, instead of a toolbox to build them? I'm concerned by skins > > > reinventing their own wheel uselessly to get to the same point at the end of the > > > day; e.g. cb_lock ops seem to me fairly generic when it comes to handling > > > futexes, so I would move them upstream one level more. > > > > > > In that respect, talking about "semaphore heaps" at nucleus level looks a bit of > > > a misnomer: if we mostly bring a service to map non-cacheable memory to > > > user-space, then we don't actually provide semaphore support. > > > > If I understand correctly, a futex is, in xenomai terms, a way to > > associate a user-space address, with an xnsynch object. > > I would specialize it more actually so that it really resembles the vanilla > futex support, i.e. a basic object implementing the required operations to > provide mutually exclusive access, working on a pinned memory area shared > between kernel and userland. AFAICS, the current patchset implements the pinned > memory support in the nucleus, but not the operations, which remain a per-skin > issue. As far as I understood, the user-space atomic operations, used to acquire a free mutex in user-space, are not part of the futex API. In our case, we are using xnarch_atomic_* operations to implement portably this user-space locking stuff. I think that even setting the bit saying that the mutex is currently owned is done in pthread_mutexes implementation, not in the Futex API. Now, what remains is sys_futex(FUTEX_WAIT) and sys_futex(FUTEX_WAKE), this terribly looks like xnsync_sleep_on and xnsynch_wakeup_one_sleeper. > > I feel this > > would complicate things: currently, the way I implemented user-space > > mutexes for the posix skin kept the old association between the > > user-space mutex, and its kernel-space companion, also used by > > kernel-space operations. > > > > My concern boils down to: how much of the POSIX implementation, beyond the > cb_lock stuff, would have to be duplicated to get the same support ported to, > say the VxWorks semM services? The initialization code, and the additional calls to xnarch_atomic_cmpxchg in user-space. If xnarch_atomic_cmpxchg fails we call kernel-space, which is mostly unchanged. Because of the cb_lock stuff, I also needed to implement the kernel-space syscalls in two versions: one if user-space has xnarch_atomic_cmpxchg and could lock the mutex control block, the other if the mutex control block needs to be locked by kernel-space. -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin 2008-05-18 19:38 ` Gilles Chanteperdrix @ 2008-05-18 21:52 ` Philippe Gerum 2008-05-18 22:52 ` Gilles Chanteperdrix 0 siblings, 1 reply; 34+ messages in thread From: Philippe Gerum @ 2008-05-18 21:52 UTC (permalink / raw) To: Gilles Chanteperdrix; +Cc: xenomai Gilles Chanteperdrix wrote: > Philippe Gerum wrote: > > Gilles Chanteperdrix wrote: > > > Philippe Gerum wrote: > > > > Gilles Chanteperdrix wrote: > > > > > The two syscalls defined in the posix skin now moved to the sys skin, they are > > > > > used in user-space by include/asm-generic/bits/bind.h and the new header > > > > > include/asm-generic/bits/current.h. The global and process-specific shared heaps > > > > > are now part of this patch. > > > > > > > > > > > > > Is there any reason why the nucleus should not implement a full-fledged "RT > > > > futex" support, instead of a toolbox to build them? I'm concerned by skins > > > > reinventing their own wheel uselessly to get to the same point at the end of the > > > > day; e.g. cb_lock ops seem to me fairly generic when it comes to handling > > > > futexes, so I would move them upstream one level more. > > > > > > > > In that respect, talking about "semaphore heaps" at nucleus level looks a bit of > > > > a misnomer: if we mostly bring a service to map non-cacheable memory to > > > > user-space, then we don't actually provide semaphore support. > > > > > > If I understand correctly, a futex is, in xenomai terms, a way to > > > associate a user-space address, with an xnsynch object. > > > > I would specialize it more actually so that it really resembles the vanilla > > futex support, i.e. a basic object implementing the required operations to > > provide mutually exclusive access, working on a pinned memory area shared > > between kernel and userland. AFAICS, the current patchset implements the pinned > > memory support in the nucleus, but not the operations, which remain a per-skin > > issue. > > As far as I understood, the user-space atomic operations, used to > acquire a free mutex in user-space, are not part of the futex API. In > our case, we are using xnarch_atomic_* operations to implement portably > this user-space locking stuff. I think that even setting the bit saying > that the mutex is currently owned is done in pthread_mutexes > implementation, not in the Futex API. I would fully agree if the futex API did not define PI-based ops, which are needed for proper real-time operations from userland. You will certainly agree that PI implies that some kind of ownership exists; and because there can't be more than a single owner in that case, you end up with an object that can't be held by more than a single task. So you do have a mutex in disguise, whatever the way to keep its state is (a bit, an integer, whatever). So there is stronger semantics attached to that API than to simply manage an event notification scheme. Now, what remains is > sys_futex(FUTEX_WAIT) and sys_futex(FUTEX_WAKE), this terribly looks like > xnsync_sleep_on and xnsynch_wakeup_one_sleeper. > Yes, here again I partially agree, except for a significant issue: xnsynch is a stateless object (that's why we can use it for different syncobjs which are totally unrelated in their semantics - mutex, queue, region, counting sems, whatever). I was just wondering if we could make the *tex thingy a bit more stateful to ease the job for the skins, just in case we would use it for mutexes only. I have no immediate answer to this question, just asking -- this is my contribution as a senior member of the peanut gallery. > > > > I feel this > > > would complicate things: currently, the way I implemented user-space > > > mutexes for the posix skin kept the old association between the > > > user-space mutex, and its kernel-space companion, also used by > > > kernel-space operations. > > > > > > > My concern boils down to: how much of the POSIX implementation, beyond the > > cb_lock stuff, would have to be duplicated to get the same support ported to, > > say the VxWorks semM services? > > The initialization code, and the additional calls to > xnarch_atomic_cmpxchg in user-space. If xnarch_atomic_cmpxchg fails we > call kernel-space, which is mostly unchanged. > > Because of the cb_lock stuff, I also needed to implement the > kernel-space syscalls in two versions: one if user-space has > xnarch_atomic_cmpxchg and could lock the mutex control block, the other > if the mutex control block needs to be locked by kernel-space. > This is the part my laziness would very much like to factor as much as possible. If ever possible. -- Philippe. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin 2008-05-18 21:52 ` Philippe Gerum @ 2008-05-18 22:52 ` Gilles Chanteperdrix 2008-05-19 12:56 ` Philippe Gerum 0 siblings, 1 reply; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-18 22:52 UTC (permalink / raw) To: rpm; +Cc: xenomai Philippe Gerum wrote: > Gilles Chanteperdrix wrote: > > As far as I understood, the user-space atomic operations, used to > > acquire a free mutex in user-space, are not part of the futex API. In > > our case, we are using xnarch_atomic_* operations to implement portably > > this user-space locking stuff. I think that even setting the bit saying > > that the mutex is currently owned is done in pthread_mutexes > > implementation, not in the Futex API. > > I would fully agree if the futex API did not define PI-based ops, which are > needed for proper real-time operations from userland. You will certainly agree > that PI implies that some kind of ownership exists; and because there can't be > more than a single owner in that case, you end up with an object that can't be > held by more than a single task. So you do have a mutex in disguise, whatever > the way to keep its state is (a bit, an integer, whatever). So there is stronger > semantics attached to that API than to simply manage an event notification scheme. > > Now, what remains is > > sys_futex(FUTEX_WAIT) and sys_futex(FUTEX_WAKE), this terribly looks like > > xnsync_sleep_on and xnsynch_wakeup_one_sleeper. > > > > Yes, here again I partially agree, except for a significant issue: xnsynch is a > stateless object (that's why we can use it for different syncobjs which are > totally unrelated in their semantics - mutex, queue, region, counting sems, > whatever). I was just wondering if we could make the *tex thingy a bit more > stateful to ease the job for the skins, just in case we would use it for mutexes > only. I have no immediate answer to this question, just asking -- this is my > contribution as a senior member of the peanut gallery. We can certainly implement an abstraction managing xnarch_atomic_t + xnsynch_t, however, it seems that we would have to re-factor all mutex/semaphores implementations to use this new abstraction. The current approach is to add an xnarch_atomic_cmpxchg in user-space, and fall back to an almost unchanged kernel-space support when it fails. > > > > > > > I feel this > > > > would complicate things: currently, the way I implemented user-space > > > > mutexes for the posix skin kept the old association between the > > > > user-space mutex, and its kernel-space companion, also used by > > > > kernel-space operations. > > > > > > > > > > My concern boils down to: how much of the POSIX implementation, beyond the > > > cb_lock stuff, would have to be duplicated to get the same support ported to, > > > say the VxWorks semM services? > > > > The initialization code, and the additional calls to > > xnarch_atomic_cmpxchg in user-space. If xnarch_atomic_cmpxchg fails we > > call kernel-space, which is mostly unchanged. > > > > Because of the cb_lock stuff, I also needed to implement the > > kernel-space syscalls in two versions: one if user-space has > > xnarch_atomic_cmpxchg and could lock the mutex control block, the other > > if the mutex control block needs to be locked by kernel-space. > > > > This is the part my laziness would very much like to factor as much as possible. > If ever possible. The current implementation is more or less: /* Common generic function */ pse51_mutex_thing_inner(mutex) { /*... Assume mutex cb is locked ... */ } /* Kernel-space operation */ pthread_mutex_thing(mutex) { cb_trylock(mutex->lock); pse51_mutex_thing_inner(mutex); cb_unlock(mutex->lock); } /* syscall wrapper */ #ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG __pthread_mutex_thing() { copy_from_user(); pse51_mutex_thing_inner(mutex) copy_to_user(); } #else __pthread_mutex_thing() { copy_from_user(); pthread_mutex_thing(mutex) copy_to_user(); } #endif -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin 2008-05-18 22:52 ` Gilles Chanteperdrix @ 2008-05-19 12:56 ` Philippe Gerum 2008-05-19 13:16 ` Gilles Chanteperdrix 0 siblings, 1 reply; 34+ messages in thread From: Philippe Gerum @ 2008-05-19 12:56 UTC (permalink / raw) To: Gilles Chanteperdrix; +Cc: xenomai Gilles Chanteperdrix wrote: > Philippe Gerum wrote: > > Gilles Chanteperdrix wrote: > > > As far as I understood, the user-space atomic operations, used to > > > acquire a free mutex in user-space, are not part of the futex API. In > > > our case, we are using xnarch_atomic_* operations to implement portably > > > this user-space locking stuff. I think that even setting the bit saying > > > that the mutex is currently owned is done in pthread_mutexes > > > implementation, not in the Futex API. > > > > I would fully agree if the futex API did not define PI-based ops, which are > > needed for proper real-time operations from userland. You will certainly agree > > that PI implies that some kind of ownership exists; and because there can't be > > more than a single owner in that case, you end up with an object that can't be > > held by more than a single task. So you do have a mutex in disguise, whatever > > the way to keep its state is (a bit, an integer, whatever). So there is stronger > > semantics attached to that API than to simply manage an event notification scheme. > > > > Now, what remains is > > > sys_futex(FUTEX_WAIT) and sys_futex(FUTEX_WAKE), this terribly looks like > > > xnsync_sleep_on and xnsynch_wakeup_one_sleeper. > > > > > > > Yes, here again I partially agree, except for a significant issue: xnsynch is a > > stateless object (that's why we can use it for different syncobjs which are > > totally unrelated in their semantics - mutex, queue, region, counting sems, > > whatever). I was just wondering if we could make the *tex thingy a bit more > > stateful to ease the job for the skins, just in case we would use it for mutexes > > only. I have no immediate answer to this question, just asking -- this is my > > contribution as a senior member of the peanut gallery. > > We can certainly implement an abstraction managing xnarch_atomic_t + > xnsynch_t, however, it seems that we would have to re-factor all > mutex/semaphores implementations to use this new abstraction. The > current approach is to add an xnarch_atomic_cmpxchg in user-space, and > fall back to an almost unchanged kernel-space support when it fails. > Ok. Let's merge this as it is. Common code will emerge eventually if it happens to make sense when plugging the feature into the native and VxWorks mutex support. > > > > > > > > > > I feel this > > > > > would complicate things: currently, the way I implemented user-space > > > > > mutexes for the posix skin kept the old association between the > > > > > user-space mutex, and its kernel-space companion, also used by > > > > > kernel-space operations. > > > > > > > > > > > > > My concern boils down to: how much of the POSIX implementation, beyond the > > > > cb_lock stuff, would have to be duplicated to get the same support ported to, > > > > say the VxWorks semM services? > > > > > > The initialization code, and the additional calls to > > > xnarch_atomic_cmpxchg in user-space. If xnarch_atomic_cmpxchg fails we > > > call kernel-space, which is mostly unchanged. > > > > > > Because of the cb_lock stuff, I also needed to implement the > > > kernel-space syscalls in two versions: one if user-space has > > > xnarch_atomic_cmpxchg and could lock the mutex control block, the other > > > if the mutex control block needs to be locked by kernel-space. > > > > > > > This is the part my laziness would very much like to factor as much as possible. > > If ever possible. > > The current implementation is more or less: > > /* Common generic function */ > pse51_mutex_thing_inner(mutex) > { > /*... Assume mutex cb is locked ... */ > } > > /* Kernel-space operation */ > pthread_mutex_thing(mutex) > { > cb_trylock(mutex->lock); > > pse51_mutex_thing_inner(mutex); > > cb_unlock(mutex->lock); > } > > /* syscall wrapper */ > #ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG > __pthread_mutex_thing() > { > copy_from_user(); > > pse51_mutex_thing_inner(mutex) > > copy_to_user(); > } > #else > __pthread_mutex_thing() > { > copy_from_user(); > > pthread_mutex_thing(mutex) > > copy_to_user(); > } > #endif > > -- Philippe. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin 2008-05-19 12:56 ` Philippe Gerum @ 2008-05-19 13:16 ` Gilles Chanteperdrix 2008-05-19 22:44 ` Gilles Chanteperdrix 0 siblings, 1 reply; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-19 13:16 UTC (permalink / raw) To: rpm; +Cc: xenomai On Mon, May 19, 2008 at 2:56 PM, Philippe Gerum <rpm@xenomai.org> wrote: > Gilles Chanteperdrix wrote: >> Philippe Gerum wrote: >> > Gilles Chanteperdrix wrote: >> > > As far as I understood, the user-space atomic operations, used to >> > > acquire a free mutex in user-space, are not part of the futex API. In >> > > our case, we are using xnarch_atomic_* operations to implement portably >> > > this user-space locking stuff. I think that even setting the bit saying >> > > that the mutex is currently owned is done in pthread_mutexes >> > > implementation, not in the Futex API. >> > >> > I would fully agree if the futex API did not define PI-based ops, which are >> > needed for proper real-time operations from userland. You will certainly agree >> > that PI implies that some kind of ownership exists; and because there can't be >> > more than a single owner in that case, you end up with an object that can't be >> > held by more than a single task. So you do have a mutex in disguise, whatever >> > the way to keep its state is (a bit, an integer, whatever). So there is stronger >> > semantics attached to that API than to simply manage an event notification scheme. >> > >> > Now, what remains is >> > > sys_futex(FUTEX_WAIT) and sys_futex(FUTEX_WAKE), this terribly looks like >> > > xnsync_sleep_on and xnsynch_wakeup_one_sleeper. >> > > >> > >> > Yes, here again I partially agree, except for a significant issue: xnsynch is a >> > stateless object (that's why we can use it for different syncobjs which are >> > totally unrelated in their semantics - mutex, queue, region, counting sems, >> > whatever). I was just wondering if we could make the *tex thingy a bit more >> > stateful to ease the job for the skins, just in case we would use it for mutexes >> > only. I have no immediate answer to this question, just asking -- this is my >> > contribution as a senior member of the peanut gallery. >> >> We can certainly implement an abstraction managing xnarch_atomic_t + >> xnsynch_t, however, it seems that we would have to re-factor all >> mutex/semaphores implementations to use this new abstraction. The >> current approach is to add an xnarch_atomic_cmpxchg in user-space, and >> fall back to an almost unchanged kernel-space support when it fails. >> > > Ok. Let's merge this as it is. Common code will emerge eventually if it happens > to make sense when plugging the feature into the native and VxWorks mutex support. Ok. I need a few more days though, to adapt it to other architectures than arm. -- Gilles ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin 2008-05-19 13:16 ` Gilles Chanteperdrix @ 2008-05-19 22:44 ` Gilles Chanteperdrix 0 siblings, 0 replies; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-19 22:44 UTC (permalink / raw) To: rpm, xenomai Gilles Chanteperdrix wrote: > On Mon, May 19, 2008 at 2:56 PM, Philippe Gerum <rpm@xenomai.org> wrote: > > Gilles Chanteperdrix wrote: > >> Philippe Gerum wrote: > >> > Gilles Chanteperdrix wrote: > >> > > As far as I understood, the user-space atomic operations, used to > >> > > acquire a free mutex in user-space, are not part of the futex API. In > >> > > our case, we are using xnarch_atomic_* operations to implement portably > >> > > this user-space locking stuff. I think that even setting the bit saying > >> > > that the mutex is currently owned is done in pthread_mutexes > >> > > implementation, not in the Futex API. > >> > > >> > I would fully agree if the futex API did not define PI-based ops, which are > >> > needed for proper real-time operations from userland. You will certainly agree > >> > that PI implies that some kind of ownership exists; and because there can't be > >> > more than a single owner in that case, you end up with an object that can't be > >> > held by more than a single task. So you do have a mutex in disguise, whatever > >> > the way to keep its state is (a bit, an integer, whatever). So there is stronger > >> > semantics attached to that API than to simply manage an event notification scheme. > >> > > >> > Now, what remains is > >> > > sys_futex(FUTEX_WAIT) and sys_futex(FUTEX_WAKE), this terribly looks like > >> > > xnsync_sleep_on and xnsynch_wakeup_one_sleeper. > >> > > > >> > > >> > Yes, here again I partially agree, except for a significant issue: xnsynch is a > >> > stateless object (that's why we can use it for different syncobjs which are > >> > totally unrelated in their semantics - mutex, queue, region, counting sems, > >> > whatever). I was just wondering if we could make the *tex thingy a bit more > >> > stateful to ease the job for the skins, just in case we would use it for mutexes > >> > only. I have no immediate answer to this question, just asking -- this is my > >> > contribution as a senior member of the peanut gallery. > >> > >> We can certainly implement an abstraction managing xnarch_atomic_t + > >> xnsynch_t, however, it seems that we would have to re-factor all > >> mutex/semaphores implementations to use this new abstraction. The > >> current approach is to add an xnarch_atomic_cmpxchg in user-space, and > >> fall back to an almost unchanged kernel-space support when it fails. > >> > > > > Ok. Let's merge this as it is. Common code will emerge eventually if it happens > > to make sense when plugging the feature into the native and VxWorks mutex support. > > Ok. I need a few more days though, to adapt it to other architectures than arm. I changed my mind and commited the whole stuff. Instead of implementing full atomic operations in user-space for other platforms than ARM, I have left this work for others. -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 4/7] Define ARM atomic operations in user-space 2008-05-02 22:34 ` [Xenomai-core] [Patch 4/7] Define ARM " Gilles Chanteperdrix 2008-05-02 22:35 ` [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin Gilles Chanteperdrix @ 2008-05-05 16:33 ` Gilles Chanteperdrix 2008-05-05 16:39 ` Philippe Gerum 1 sibling, 1 reply; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-05 16:33 UTC (permalink / raw) To: xenomai On Sat, May 3, 2008 at 12:34 AM, Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org> wrote: > > The include/asm-arm/atomic.h header now defines the xnarch_memory_barrier in > addition to user-space atomic operations. The pxa3xx deserves a special > treatment since it uses the ARMv6 memory barrier operation whereas being an > ARMv5 for other operations, hence a special --enable-arm-mach=pxa3xx option in > configure.in. After a quick look at all architectures xenomai supports, it seems that we can implement atomic_cmpxchg for most of them in user-space. The only one for which I have a doubt is blackfin. Since linux for blackfin is uclinux, can we call cli/sti from user-space ? -- Gilles ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 4/7] Define ARM atomic operations in user-space 2008-05-05 16:33 ` [Xenomai-core] [Patch 4/7] Define ARM atomic operations in user-space Gilles Chanteperdrix @ 2008-05-05 16:39 ` Philippe Gerum 2008-05-05 16:44 ` Gilles Chanteperdrix 0 siblings, 1 reply; 34+ messages in thread From: Philippe Gerum @ 2008-05-05 16:39 UTC (permalink / raw) To: Gilles Chanteperdrix; +Cc: xenomai Gilles Chanteperdrix wrote: > On Sat, May 3, 2008 at 12:34 AM, Gilles Chanteperdrix > <gilles.chanteperdrix@xenomai.org> wrote: >> The include/asm-arm/atomic.h header now defines the xnarch_memory_barrier in >> addition to user-space atomic operations. The pxa3xx deserves a special >> treatment since it uses the ARMv6 memory barrier operation whereas being an >> ARMv5 for other operations, hence a special --enable-arm-mach=pxa3xx option in >> configure.in. > > After a quick look at all architectures xenomai supports, it seems > that we can implement atomic_cmpxchg for most of them in user-space. > The only one for which I have a doubt is blackfin. Since linux for > blackfin is uclinux, can we call cli/sti from user-space ? > Nope, these are supervisor's toys on this arch. IIRC, recent Blackfin releases should be providing fast atomic ops from userland despite this, by using protected jumps to kernel space for that purpose. I need to check that in the kernel code, this was a discussion running on the Blackfin dev-list months ago. Anyway, I would suggest to exclude Blackfin from the mutex optimization set right now, then go back to it when we support their latest kernel. -- Philippe. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 4/7] Define ARM atomic operations in user-space 2008-05-05 16:39 ` Philippe Gerum @ 2008-05-05 16:44 ` Gilles Chanteperdrix 0 siblings, 0 replies; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-05 16:44 UTC (permalink / raw) To: rpm; +Cc: xenomai On Mon, May 5, 2008 at 6:39 PM, Philippe Gerum <rpm@xenomai.org> wrote: > > Gilles Chanteperdrix wrote: > > On Sat, May 3, 2008 at 12:34 AM, Gilles Chanteperdrix > > <gilles.chanteperdrix@xenomai.org> wrote: > >> The include/asm-arm/atomic.h header now defines the xnarch_memory_barrier in > >> addition to user-space atomic operations. The pxa3xx deserves a special > >> treatment since it uses the ARMv6 memory barrier operation whereas being an > >> ARMv5 for other operations, hence a special --enable-arm-mach=pxa3xx option in > >> configure.in. > > > > After a quick look at all architectures xenomai supports, it seems > > that we can implement atomic_cmpxchg for most of them in user-space. > > The only one for which I have a doubt is blackfin. Since linux for > > blackfin is uclinux, can we call cli/sti from user-space ? > > > > Nope, these are supervisor's toys on this arch. IIRC, recent Blackfin releases > should be providing fast atomic ops from userland despite this, by using > protected jumps to kernel space for that purpose. I need to check that in the > kernel code, this was a discussion running on the Blackfin dev-list months ago. It looks like the same technique as used on pre-v6 ARM. > Anyway, I would suggest to exclude Blackfin from the mutex optimization set > right now, then go back to it when we support their latest kernel. Ok. I was dreaming about removing all the #ifdef XNARCH_HAVE_US_ATOMIC_CMPXCHG. But it is probably better to leave it after all. If for anything, it will help people doing ports to new architectures gradually. -- Gilles ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 1/7] Support for non cached memory mappings 2008-05-02 22:30 ` [Xenomai-core] [Patch 1/7] Support for non cached memory mappings Gilles Chanteperdrix 2008-05-02 22:32 ` [Xenomai-core] [Patch 2/7] Define XNARCH_SHARED_HEAP_FLAGS Gilles Chanteperdrix @ 2008-05-18 16:30 ` Philippe Gerum 1 sibling, 0 replies; 34+ messages in thread From: Philippe Gerum @ 2008-05-18 16:30 UTC (permalink / raw) To: Gilles Chanteperdrix; +Cc: xenomai Gilles Chanteperdrix wrote: > In addition to support for non cached memory mappings, this patch implements > xnheap_init_mapped and xnheap_destroy_mapped in the !CONFIG_XENO_OPT_PERVASIVE > case. This avoids a lot of #ifdefs for users of these functions without > user-space support (posix skin shared memories, and the new semaphore heaps, > heaps where is allocated the memory used for storing semaphores counters and > mutexes owner fields). > Looks good. I would suggest to make xnheap_init_mapped() whine and bail out when non-cached DMA memory is requested though. > --- > include/asm-generic/wrappers.h | 12 +++++--- > include/native/heap.h | 1 > include/nucleus/heap.h | 2 + > ksrc/nucleus/heap.c | 55 +++++++++++++++++++++++++++++++++++------ > ksrc/skins/native/heap.c | 8 +++++ > 5 files changed, 66 insertions(+), 12 deletions(-) > > Index: include/native/heap.h > =================================================================== > --- include/native/heap.h (revision 3738) > +++ include/native/heap.h (working copy) > @@ -33,6 +33,7 @@ > #define H_MAPPABLE 0x200 /* Memory is mappable to user-space. */ > #define H_SINGLE 0x400 /* Manage as single-block area. */ > #define H_SHARED (H_MAPPABLE|H_SINGLE) /* I.e. shared memory segment. */ > +#define H_NONCACHED 0x800 > > /** Structure containing heap-information useful to users. > * > Index: include/asm-generic/wrappers.h > =================================================================== > --- include/asm-generic/wrappers.h (revision 3738) > +++ include/asm-generic/wrappers.h (working copy) > @@ -62,7 +62,7 @@ unsigned long __va_to_kva(unsigned long > > #define wrap_remap_vm_page(vma,from,to) ({ \ > vma->vm_flags |= VM_RESERVED; \ > - remap_page_range(from,virt_to_phys((void *)__va_to_kva(to)),PAGE_SIZE,PAGE_SHARED); \ > + remap_page_range(from,virt_to_phys((void *)__va_to_kva(to)),PAGE_SIZE,vma->vm_page_prot); \ > }) > #define wrap_remap_io_page_range(vma,from,to,size,prot) ({ \ > vma->vm_flags |= VM_RESERVED; \ > @@ -223,7 +223,7 @@ unsigned long __va_to_kva(unsigned long > * memory. Anyway, this legacy would only hit setups using pre-2.6.11 > * kernel revisions. */ > #define wrap_remap_vm_page(vma,from,to) \ > - remap_pfn_range(vma,from,virt_to_phys((void *)__va_to_kva(to)) >> PAGE_SHIFT,PAGE_SHIFT,PAGE_SHARED) > + remap_pfn_range(vma,from,virt_to_phys((void *)__va_to_kva(to)) >> PAGE_SHIFT,PAGE_SHIFT,vma->vm_page_prot) > #define wrap_remap_io_page_range(vma,from,to,size,prot) ({ \ > (vma)->vm_page_prot = pgprot_noncached((vma)->vm_page_prot); \ > /* Sets VM_RESERVED | VM_IO | VM_PFNMAP on the vma. */ \ > @@ -236,7 +236,7 @@ unsigned long __va_to_kva(unsigned long > #else /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) */ > #define wrap_remap_vm_page(vma,from,to) ({ \ > vma->vm_flags |= VM_RESERVED; \ > - remap_page_range(from,virt_to_phys((void *)__va_to_kva(to)),PAGE_SIZE,PAGE_SHARED); \ > + remap_page_range(from,virt_to_phys((void *)__va_to_kva(to)),PAGE_SIZE,vma->vm_page_prot); \ > }) > #define wrap_remap_io_page_range(vma,from,to,size,prot) ({ \ > vma->vm_flags |= VM_RESERVED; \ > @@ -248,7 +248,11 @@ unsigned long __va_to_kva(unsigned long > }) > #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15) */ > > -#define wrap_switch_mm(prev,next,task) \ > +#ifndef __GFP_BITS_SHIFT > +#define __GFP_BITS_SHIFT 20 > +#endif > + > +#define wrap_switch_mm(prev,next,task) \ > switch_mm(prev,next,task) > #define wrap_enter_lazy_tlb(mm,task) \ > enter_lazy_tlb(mm,task) > Index: include/nucleus/heap.h > =================================================================== > --- include/nucleus/heap.h (revision 3738) > +++ include/nucleus/heap.h (working copy) > @@ -57,6 +57,8 @@ > #define XNHEAP_PCONT 1 > #define XNHEAP_PLIST 2 > > +#define XNHEAP_GFP_NONCACHED (1 << __GFP_BITS_SHIFT) > + > typedef struct xnextent { > > xnholder_t link; > Index: ksrc/skins/native/heap.c > =================================================================== > --- ksrc/skins/native/heap.c (revision 3738) > +++ ksrc/skins/native/heap.c (working copy) > @@ -205,6 +205,10 @@ static void __heap_flush_private(xnheap_ > * operations with I/O devices. The physical address of the > * heap can be obtained by a call to rt_heap_inquire(). > * > + * - H_NONCACHED causes the heap not to be cached. This is necessary on > + * platforms such as ARM to share a heap between kernel and user-space. > + * Note that this flag is not compatible with the H_DMA flag. > + * > * @return 0 is returned upon success. Otherwise: > * > * - -EEXIST is returned if the @a name is already in use by some > @@ -260,7 +264,9 @@ int rt_heap_create(RT_HEAP *heap, const > > err = xnheap_init_mapped(&heap->heap_base, > heapsize, > - (mode & H_DMA) ? GFP_DMA : 0); > + ((mode & H_DMA) ? GFP_DMA : 0) > + | ((mode & H_NONCACHED) ? > + XNHEAP_GFP_NONCACHED : 0)); > if (err) > return err; > > Index: ksrc/nucleus/heap.c > =================================================================== > --- ksrc/nucleus/heap.c (revision 3738) > +++ ksrc/nucleus/heap.c (working copy) > @@ -1097,9 +1097,13 @@ static int xnheap_mmap(struct file *file > > vaddr = (unsigned long)heap->archdep.heapbase; > > - if (!heap->archdep.kmflags) { > + if (!heap->archdep.kmflags > + || heap->archdep.kmflags == XNHEAP_GFP_NONCACHED) { > unsigned long maddr = vma->vm_start; > > + if (heap->archdep.kmflags == XNHEAP_GFP_NONCACHED) > + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); > + > while (size > 0) { > if (xnarch_remap_vm_page(vma, maddr, vaddr)) > return -EAGAIN; > @@ -1174,9 +1178,13 @@ static inline void *__alloc_and_reserve_ > > /* Size must be page-aligned. */ > > - if (!kmflags) { > - ptr = vmalloc(size); > - > + if (!kmflags || kmflags == XNHEAP_GFP_NONCACHED) { > + if (!kmflags) > + ptr = vmalloc(size); > + else > + ptr = __vmalloc(size, > + GFP_KERNEL | __GFP_HIGHMEM, > + pgprot_noncached(PAGE_KERNEL)); > if (!ptr) > return NULL; > > @@ -1217,7 +1225,7 @@ static inline void __unreserve_and_free_ > > vabase = (unsigned long)ptr; > > - if (!kmflags) { > + if (!kmflags || kmflags == XNHEAP_GFP_NONCACHED) { > for (vaddr = vabase; vaddr < vabase + size; vaddr += PAGE_SIZE) > ClearPageReserved(virt_to_page(__va_to_kva(vaddr))); > > @@ -1241,6 +1249,11 @@ int xnheap_init_mapped(xnheap_t *heap, u > > /* Caller must have accounted for internal overhead. */ > heapsize = xnheap_align(heapsize, PAGE_SIZE); > + > + if ((memflags & XNHEAP_GFP_NONCACHED) > + && memflags != XNHEAP_GFP_NONCACHED) > + return -EINVAL; > + > heapbase = __alloc_and_reserve_heap(heapsize, memflags); > > if (!heapbase) > @@ -1284,11 +1297,39 @@ int xnheap_destroy_mapped(xnheap_t *heap > return 0; > } > > -EXPORT_SYMBOL(xnheap_init_mapped); > -EXPORT_SYMBOL(xnheap_destroy_mapped); > +#else /* !CONFIG_XENO_OPT_PERVASIVE */ > +static void xnheap_free_extent(xnheap_t *heap, > + void *extent, u_long size, void *cookie) > +{ > + xnarch_free_host_mem(extent, size); > +} > + > +int xnheap_init_mapped(xnheap_t *heap, unsigned len, int flags) > +{ > + void *heapaddr = xnarch_alloc_host_mem(len); > + int err; > > + if (heapaddr) { > + err = xnheap_init(&shm->heapbase, > + heapaddr, len, XNCORE_PAGE_SIZE); > + if (err) > + xnarch_free_host_mem(heapaddr, len); > + > + return err; > + } > + > + return -ENOMEM; > +} > + > +void xnheap_destroy_mapped(xnheap_t *heap) > +{ > + xnheap_destroy(heap, &xnheap_free_extent, NULL); > +} > #endif /* CONFIG_XENO_OPT_PERVASIVE */ > > +EXPORT_SYMBOL(xnheap_init_mapped); > +EXPORT_SYMBOL(xnheap_destroy_mapped); > + > /*@}*/ > > EXPORT_SYMBOL(xnheap_alloc); > -- Philippe. ^ permalink raw reply [flat|nested] 34+ messages in thread
* Re: [Xenomai-core] [Patch 0/7] Posix skin user-space mutexes, second take. 2008-05-02 22:27 [Xenomai-core] [Patch 0/7] Posix skin user-space mutexes, second take Gilles Chanteperdrix 2008-05-02 22:30 ` [Xenomai-core] [Patch 1/7] Support for non cached memory mappings Gilles Chanteperdrix @ 2008-05-03 19:18 ` Gilles Chanteperdrix 1 sibling, 0 replies; 34+ messages in thread From: Gilles Chanteperdrix @ 2008-05-03 19:18 UTC (permalink / raw) To: xenomai Gilles Chanteperdrix wrote: > > Hi, > > here comes a second attempt of implementing user-space mutexes for the posix > skin. > > Only differences with the first implementation are explained in the following > mails. > > Thanks in advance for your review. After extensive testing, except for bugs in condition variables system calls, the new implementation seems to work fine. Of course, it is well known that the one who makes the test should not be the same as the one who makes the code... -- Gilles. ^ permalink raw reply [flat|nested] 34+ messages in thread
end of thread, other threads:[~2008-05-20 7:23 UTC | newest] Thread overview: 34+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2008-05-02 22:27 [Xenomai-core] [Patch 0/7] Posix skin user-space mutexes, second take Gilles Chanteperdrix 2008-05-02 22:30 ` [Xenomai-core] [Patch 1/7] Support for non cached memory mappings Gilles Chanteperdrix 2008-05-02 22:32 ` [Xenomai-core] [Patch 2/7] Define XNARCH_SHARED_HEAP_FLAGS Gilles Chanteperdrix 2008-05-02 22:33 ` [Xenomai-core] [Patch 3/7] Define more atomic operations in user-space Gilles Chanteperdrix 2008-05-02 22:34 ` [Xenomai-core] [Patch 4/7] Define ARM " Gilles Chanteperdrix 2008-05-02 22:35 ` [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin Gilles Chanteperdrix 2008-05-02 22:36 ` [Xenomai-core] [Patch 6/7] Re-implementation of mutexes, kernel-space support Gilles Chanteperdrix 2008-05-02 22:38 ` [Xenomai-core] [Patch 7/7] Re-implementation of mutexes, user-space support Gilles Chanteperdrix 2008-05-18 16:42 ` Philippe Gerum 2008-05-18 17:05 ` Gilles Chanteperdrix 2008-05-18 17:29 ` Jan Kiszka 2008-05-18 17:41 ` Gilles Chanteperdrix 2008-05-18 17:52 ` Jan Kiszka 2008-05-18 18:09 ` Gilles Chanteperdrix 2008-05-18 18:56 ` Philippe Gerum 2008-05-19 22:49 ` Gilles Chanteperdrix 2008-05-20 6:53 ` Philippe Gerum 2008-05-20 7:07 ` Jan Kiszka 2008-05-20 7:23 ` Gilles Chanteperdrix 2008-05-18 16:40 ` [Xenomai-core] [Patch 5/7] Define new syscalls for the system skin Philippe Gerum 2008-05-18 17:21 ` Gilles Chanteperdrix 2008-05-18 18:37 ` Gilles Chanteperdrix 2008-05-18 19:10 ` Philippe Gerum 2008-05-18 19:38 ` Gilles Chanteperdrix 2008-05-18 21:52 ` Philippe Gerum 2008-05-18 22:52 ` Gilles Chanteperdrix 2008-05-19 12:56 ` Philippe Gerum 2008-05-19 13:16 ` Gilles Chanteperdrix 2008-05-19 22:44 ` Gilles Chanteperdrix 2008-05-05 16:33 ` [Xenomai-core] [Patch 4/7] Define ARM atomic operations in user-space Gilles Chanteperdrix 2008-05-05 16:39 ` Philippe Gerum 2008-05-05 16:44 ` Gilles Chanteperdrix 2008-05-18 16:30 ` [Xenomai-core] [Patch 1/7] Support for non cached memory mappings Philippe Gerum 2008-05-03 19:18 ` [Xenomai-core] [Patch 0/7] Posix skin user-space mutexes, second take Gilles Chanteperdrix
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.