/*
|
* Copyright (C) 2009 Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>.
|
*
|
* This library is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU Lesser General Public
|
* License as published by the Free Software Foundation; either
|
* version 2 of the License, or (at your option) any later version.
|
*
|
* This library is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
* Lesser General Public License for more details.
|
|
* You should have received a copy of the GNU Lesser General Public
|
* License along with this library; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
*/
|
#include <sys/types.h>
|
#include <sys/stat.h>
|
#include <sys/ioctl.h>
|
#include <sys/mman.h>
|
#include <stdio.h>
|
#include <errno.h>
|
#include <stdlib.h>
|
#include <stdint.h>
|
#include <string.h>
|
#include <unistd.h>
|
#include <fcntl.h>
|
#include <pthread.h>
|
#include <rtdm/rtdm.h>
|
#include <cobalt/uapi/kernel/heap.h>
|
#include <asm/xenomai/syscall.h>
|
#include "current.h"
|
#include "umm.h"
|
#include "internal.h"
|
|
struct xnvdso *cobalt_vdso;
|
|
void *cobalt_umm_private = NULL;
|
|
void *cobalt_umm_shared = NULL;
|
|
static pthread_once_t init_bind_once = PTHREAD_ONCE_INIT;
|
|
static uint32_t private_size;
|
|
static void *__map_umm(const char *name, uint32_t *size_r)
|
{
|
struct cobalt_memdev_stat statbuf;
|
int fd, ret;
|
void *addr;
|
|
fd = __RT(open(name, O_RDWR));
|
if (fd < 0) {
|
early_warning("cannot open RTDM device %s: %s", name,
|
strerror(errno));
|
return MAP_FAILED;
|
}
|
|
ret = __RT(ioctl(fd, MEMDEV_RTIOC_STAT, &statbuf));
|
if (ret) {
|
__RT(close(fd));
|
early_warning("failed getting status of %s: %s",
|
name, strerror(errno));
|
return MAP_FAILED;
|
}
|
|
addr = __RT(mmap(NULL, statbuf.size, PROT_READ|PROT_WRITE,
|
MAP_SHARED, fd, 0));
|
__RT(close(fd));
|
|
*size_r = statbuf.size;
|
|
return addr;
|
}
|
|
#define map_umm(__name, __size_r) __map_umm("/dev/rtdm/" __name, __size_r)
|
|
void cobalt_unmap_umm(void)
|
{
|
void *addr;
|
|
/*
|
* Remapping the private heap must be done after the process
|
* has re-attached to the Cobalt core, in order to reinstate a
|
* proper private heap, Otherwise the global heap would be
|
* used instead, leading to unwanted effects.
|
*
|
* On machines without an MMU, there is no such thing as fork.
|
*
|
* We replace former mappings with an invalid one, to detect
|
* any spurious late access.
|
*/
|
addr = __STD(mmap(cobalt_umm_private,
|
private_size, PROT_NONE,
|
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0));
|
|
if (addr != cobalt_umm_private)
|
munmap(cobalt_umm_private, private_size);
|
|
cobalt_umm_private = NULL;
|
init_bind_once = PTHREAD_ONCE_INIT;
|
}
|
|
/*
|
* Will be called once on behalf of xenomai_init(), and when
|
* re-binding after a fork.
|
*/
|
static void init_bind(void)
|
{
|
cobalt_umm_private = map_umm(COBALT_MEMDEV_PRIVATE, &private_size);
|
if (cobalt_umm_private == MAP_FAILED) {
|
early_warning("cannot map private umm area: %s",
|
strerror(errno));
|
early_panic("(CONFIG_DEVTMPFS_MOUNT not enabled?)");
|
}
|
}
|
|
/* Will be called only once, upon call to xenomai_init(). */
|
static void init_loadup(__u32 vdso_offset)
|
{
|
uint32_t size;
|
|
cobalt_umm_shared = map_umm(COBALT_MEMDEV_SHARED, &size);
|
if (cobalt_umm_shared == MAP_FAILED)
|
early_panic("cannot map shared umm area: %s",
|
strerror(errno));
|
|
cobalt_vdso = (struct xnvdso *)(cobalt_umm_shared + vdso_offset);
|
}
|
|
void cobalt_init_umm(__u32 vdso_offset)
|
{
|
pthread_once(&init_bind_once, init_bind);
|
init_loadup(vdso_offset);
|
}
|
