void xnmod_alloc_glinks(xnqueue_t *freehq)
{
xngholder_t *sholder, *eholder;
sholder = xnheap_alloc(&kheap,
sizeof(xngholder_t) * XNMOD_GHOLDER_REALLOC);
if (!sholder) {
/* If we are running out of memory but still have some free
holders, just return silently, hoping that the contention
will disappear before we have no other choice than
allocating memory eventually. Otherwise, we have to raise a
fatal error right now. */
if (emptyq_p(freehq))
xnpod_fatal("cannot allocate generic holders");
return;
}
for (eholder = sholder + XNMOD_GHOLDER_REALLOC;
sholder < eholder; sholder++) {
inith(&sholder->glink.plink);
appendq(freehq, &sholder->glink.plink);
}
}
int rt_heap_free(RT_HEAP *heap, void *block)
{
int err, nwake;
spl_t s;
if (block == NULL)
return -EINVAL;
xnlock_get_irqsave(&nklock, s);
heap = xeno_h2obj_validate(heap, XENO_HEAP_MAGIC, RT_HEAP);
if (!heap) {
err = xeno_handle_error(heap, XENO_HEAP_MAGIC, RT_HEAP);
goto unlock_and_exit;
}
if (heap->mode & H_SINGLE) { /* No-op in single-block mode. */
err = 0;
goto unlock_and_exit;
}
err = xnheap_free(&heap->heap_base, block);
if (!err && xnsynch_nsleepers(&heap->synch_base) > 0) {
xnpholder_t *holder, *nholder;
nholder = getheadpq(xnsynch_wait_queue(&heap->synch_base));
nwake = 0;
while ((holder = nholder) != NULL) {
RT_TASK *sleeper =
thread2rtask(link2thread(holder, plink));
void *block;
block = xnheap_alloc(&heap->heap_base,
sleeper->wait_args.heap.size);
if (block) {
nholder =
xnsynch_wakeup_this_sleeper(&heap->
synch_base,
holder);
sleeper->wait_args.heap.block = block;
nwake++;
} else
nholder =
nextpq(xnsynch_wait_queue
(&heap->synch_base), holder);
}
if (nwake > 0)
xnpod_schedule();
}
unlock_and_exit:
xnlock_put_irqrestore(&nklock, s);
return err;
}
static xnshm_a_t *kalloc_new_shm(unsigned long name, int size)
{
xnshm_a_t *p;
p = xnheap_alloc(&kheap, sizeof(xnshm_a_t));
if (!p)
return NULL;
p->chunk = xnheap_alloc(&kheap, size);
if (!p->chunk) {
xnheap_free(&kheap, p);
return NULL;
}
memset(p->chunk, 0, size);
inith(&p->link);
p->ref = 1;
p->name = name;
p->size = size;
p->heap = &kheap;
return p;
}
/**
* Truncate a file or shared memory object to a specified length.
*
* When used in kernel-space, this service set to @a len the size of a shared
* memory object opened with the shm_open() service. In user-space this service
* falls back to Linux regular ftruncate service for file descriptors not
* obtained with shm_open(). When this service is used to increase the size of a
* shared memory object, the added space is zero-filled.
*
* Shared memory are suitable for direct memory access (allocated in physically
* contiguous memory) if O_DIRECT was passed to shm_open.
*
* Shared memory objects may only be resized if they are not currently mapped.
*
* @param fd file descriptor;
*
* @param len new length of the underlying file or shared memory object.
*
* @retval 0 on success;
* @retval -1 with @a errno set if:
* - EBADF, @a fd is not a valid file descriptor;
* - EPERM, the caller context is invalid;
* - EINVAL, the specified length is invalid;
* - EINVAL, the architecture can not honour the O_DIRECT flag;
* - EINTR, this service was interrupted by a signal;
* - EBUSY, @a fd is a shared memory object descriptor and the underlying shared
* memory is currently mapped;
* - EFBIG, allocation of system memory failed.
*
* @par Valid contexts:
* - kernel module initialization or cleanup routine;
* - user-space thread (Xenomai threads switch to secondary mode).
*
* @see
* <a href="http://www.opengroup.org/onlinepubs/000095399/functions/ftruncate.html">
* Specification.</a>
*
*/
int ftruncate(int fd, off_t len)
{
unsigned desc_flags;
pse51_desc_t *desc;
pse51_shm_t *shm;
int err;
spl_t s;
xnlock_get_irqsave(&nklock, s);
shm = pse51_shm_get(&desc, fd, 1);
if (IS_ERR(shm)) {
err = -PTR_ERR(shm);
xnlock_put_irqrestore(&nklock, s);
goto error;
}
if (xnpod_asynch_p() || !xnpod_root_p()) {
err = EPERM;
xnlock_put_irqrestore(&nklock, s);
goto err_shm_put;
}
if (len < 0) {
err = EINVAL;
xnlock_put_irqrestore(&nklock, s);
goto err_shm_put;
}
desc_flags = pse51_desc_getflags(desc);
xnlock_put_irqrestore(&nklock, s);
if (down_interruptible(&shm->maplock)) {
err = EINTR;
goto err_shm_put;
}
/* Allocate one more page for alignment (the address returned by mmap
must be aligned on a page boundary). */
if (len)
#ifdef CONFIG_XENO_OPT_PERVASIVE
len = xnheap_rounded_size(len + PAGE_SIZE, PAGE_SIZE);
#else /* !CONFIG_XENO_OPT_PERVASIVE */
len = xnheap_rounded_size(len + PAGE_SIZE, XNHEAP_PAGE_SIZE);
#endif /* !CONFIG_XENO_OPT_PERVASIVE */
err = 0;
if (emptyq_p(&shm->mappings)) {
/* Temporary storage, in order to preserve the memory contents upon
resizing, if possible. */
void *addr = NULL;
size_t size = 0;
if (shm->addr) {
if (len == xnheap_extentsize(&shm->heapbase)) {
/* Size unchanged, skip copy and reinit. */
err = 0;
goto err_up;
}
size = xnheap_max_contiguous(&shm->heapbase);
addr = xnarch_alloc_host_mem(size);
if (!addr) {
err = ENOMEM;
goto err_up;
}
memcpy(addr, shm->addr, size);
xnheap_free(&shm->heapbase, shm->addr);
xnheap_destroy_mapped(&shm->heapbase, NULL, NULL);
shm->addr = NULL;
shm->size = 0;
}
if (len) {
int flags = XNARCH_SHARED_HEAP_FLAGS |
((desc_flags & O_DIRECT) ? GFP_DMA : 0);
err = -xnheap_init_mapped(&shm->heapbase, len, flags);
if (err)
goto err_up;
xnheap_set_label(&shm->heapbase,
"posix shm: %s", shm->nodebase.name);
shm->size = xnheap_max_contiguous(&shm->heapbase);
shm->addr = xnheap_alloc(&shm->heapbase, shm->size);
/* Required. */
memset(shm->addr, '\0', shm->size);
/* Copy the previous contents. */
if (addr)
memcpy(shm->addr, addr,
shm->size < size ? shm->size : size);
shm->size -= PAGE_SIZE;
}
if (addr)
xnarch_free_host_mem(addr, size);
} else if (len != xnheap_extentsize(&shm->heapbase))
err = EBUSY;
err_up:
up(&shm->maplock);
err_shm_put:
pse51_shm_put(shm, 1);
if (!err)
return 0;
error:
thread_set_errno(err == ENOMEM ? EFBIG : err);
return -1;
}
static xnshm_a_t *create_new_heap(unsigned long name, int heapsize, int suprt)
{
xnshm_a_t *p;
int err;
p = xnheap_alloc(&kheap, sizeof(xnshm_a_t));
if (!p)
return NULL;
p->heap = xnheap_alloc(&kheap, sizeof(xnheap_t));
if (!p->heap) {
xnheap_free(&kheap, p);
return NULL;
}
/*
* Account for the minimum heap size and overhead so that the
* actual free space is large enough to match the requested
* size.
*/
#ifdef CONFIG_XENO_OPT_PERVASIVE
heapsize = xnheap_rounded_size(heapsize, PAGE_SIZE);
err = xnheap_init_mapped(p->heap,
heapsize,
suprt == USE_GFP_KERNEL ? GFP_KERNEL : 0);
#else /* !CONFIG_XENO_OPT_PERVASIVE */
{
void *heapmem;
heapsize = xnheap_rounded_size(heapsize, XNCORE_PAGE_SIZE);
heapmem = xnarch_alloc_host_mem(heapsize);
if (!heapmem) {
err = -ENOMEM;
} else {
err = xnheap_init(p->heap, heapmem, heapsize, XNCORE_PAGE_SIZE);
if (err) {
xnarch_free_host_mem(heapmem, heapsize);
}
}
}
#endif /* !CONFIG_XENO_OPT_PERVASIVE */
if (err) {
xnheap_free(&kheap, p->heap);
xnheap_free(&kheap, p);
return NULL;
}
p->chunk = xnheap_mapped_address(p->heap, 0);
memset(p->chunk, 0, heapsize);
inith(&p->link);
p->ref = 1;
p->name = name;
p->size = heapsize;
return p;
}
int rt_heap_alloc(RT_HEAP *heap, size_t size, RTIME timeout, void **blockp)
{
void *block = NULL;
xnthread_t *thread;
xnflags_t info;
int err = 0;
spl_t s;
xnlock_get_irqsave(&nklock, s);
heap = xeno_h2obj_validate(heap, XENO_HEAP_MAGIC, RT_HEAP);
if (!heap) {
err = xeno_handle_error(heap, XENO_HEAP_MAGIC, RT_HEAP);
goto unlock_and_exit;
}
/* In single-block mode, there is only a single allocation
returning the whole addressable heap space to the user. All
users referring to this heap are then returned the same
block. */
if (heap->mode & H_SINGLE) {
block = heap->sba;
if (!block) {
/* It's ok to pass zero for size here, since the requested
size is implicitely the whole heap space; but if
non-zero is given, it must match the original heap
size. */
if (size > 0 && size != heap->csize) {
err = -EINVAL;
goto unlock_and_exit;
}
block = heap->sba = xnheap_alloc(&heap->heap_base,
xnheap_max_contiguous
(&heap->heap_base));
}
if (block)
goto unlock_and_exit;
err = -ENOMEM; /* This should never happen. Paranoid. */
goto unlock_and_exit;
}
block = xnheap_alloc(&heap->heap_base, size);
if (block)
goto unlock_and_exit;
if (timeout == TM_NONBLOCK) {
err = -EWOULDBLOCK;
goto unlock_and_exit;
}
if (xnpod_unblockable_p()) {
err = -EPERM;
goto unlock_and_exit;
}
thread = xnpod_current_thread();
thread->wait_u.buffer.size = size;
thread->wait_u.buffer.ptr = NULL;
info = xnsynch_sleep_on(&heap->synch_base, timeout, XN_RELATIVE);
if (info & XNRMID)
err = -EIDRM; /* Heap deleted while pending. */
else if (info & XNTIMEO)
err = -ETIMEDOUT; /* Timeout. */
else if (info & XNBREAK)
err = -EINTR; /* Unblocked. */
else
block = thread->wait_u.buffer.ptr;
unlock_and_exit:
*blockp = block;
xnlock_put_irqrestore(&nklock, s);
return err;
}
static int __sc_pcreate(struct task_struct *curr, struct pt_regs *regs)
{
u_long ptsize, bsize;
vrtx_pdesc_t pdesc;
xnheap_t *ptheap;
vrtxpt_t *pt;
int err, pid;
char *ptaddr;
spl_t s;
if (!__xn_access_ok
(curr, VERIFY_WRITE, __xn_reg_arg4(regs), sizeof(pdesc)))
return -EFAULT;
ptheap = (xnheap_t *)xnmalloc(sizeof(*ptheap));
if (!ptheap)
return ER_MEM;
/* Suggested partition ID. */
pid = __xn_reg_arg1(regs);
/* Size of partition space -- account for the heap mgmt overhead. */
ptsize = __xn_reg_arg2(regs);
/* Shared heaps use the natural page size (PAGE_SIZE) */
ptsize = xnheap_rounded_size(ptsize, PAGE_SIZE);
/* Block size. */
bsize = __xn_reg_arg3(regs);
err = xnheap_init_mapped(ptheap, ptsize, 0);
if (err)
goto free_heap;
/* Allocate the partition space as a single shared heap block. */
ptaddr = xnheap_alloc(ptheap, ptsize);
pid = sc_pcreate(pid, ptaddr, ptsize, bsize, &err);
if (err)
goto unmap_pt;
xnlock_get_irqsave(&nklock, s);
pt = xnmap_fetch(vrtx_pt_idmap, pid);
if (pt) { /* Paranoid. */
pt->mm = curr->mm;
pt->sysheap = ptheap;
pdesc.pid = pid;
pdesc.ptcb = ptheap;
pdesc.ptsize = xnheap_extentsize(ptheap);
xnlock_put_irqrestore(&nklock, s);
__xn_copy_to_user(curr, (void __user *)__xn_reg_arg4(regs),
&pdesc, sizeof(pdesc));
return 0;
}
xnlock_put_irqrestore(&nklock, s);
err = ER_PID;
unmap_pt:
xnheap_destroy_mapped(ptheap, NULL, NULL);
free_heap:
xnfree(ptheap);
return err;
}
