/*
 * Copyright (C) 2008 Philippe Gerum <rpm@xenomai.org>.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */

#include <stdio.h>
#include <stdint.h>
#include <errno.h>
#include <stdlib.h>
#include <memory.h>
#include <boilerplate/ancillaries.h>
#include <copperplate/threadobj.h>
#include <copperplate/clockobj.h>
#include <psos/psos.h>
#include "internal.h"
#include "tm.h"
#include "rn.h"

#define rn_magic	0x8181efef

struct pvcluster psos_rn_table;

static unsigned long anon_rnids;

static struct psos_rn *get_rn_from_id(u_long rnid, int *err_r)
{
	struct psos_rn *rn = mainheap_deref(rnid, struct psos_rn);

	if (rn == NULL || ((uintptr_t)rn & (sizeof(uintptr_t)-1)) != 0)
		goto objid_error;

	if (rn->magic == rn_magic)
		return rn;

	if (rn->magic == ~rn_magic) {
		*err_r = ERR_OBJDEL;
		return NULL;
	}

	if ((rn->magic >> 16) == 0x8181) {
		*err_r = ERR_OBJTYPE;
		return NULL;
	}

objid_error:
	*err_r = ERR_OBJID;

	return NULL;
}

u_long rn_create(const char *name, void *saddr, u_long length,
		 u_long usize, u_long flags, u_long *rnid_r,
		 u_long *asize_r)
{
	int sobj_flags = 0, ret = SUCCESS;
	struct psos_rn *rn;
	struct service svc;
	char short_name[5];

	if ((uintptr_t)saddr & (sizeof(uintptr_t) - 1))
		return ERR_RNADDR;

	if (usize < 16)
		return ERR_TINYUNIT;

	if ((usize & (usize - 1)) != 0)
		return ERR_UNITSIZE;	/* Not a power of two. */

	if (length <= sizeof(*rn))
		return ERR_TINYRN;

	if (flags & RN_PRIOR)
		sobj_flags = SYNCOBJ_PRIO;

	/*
	 * XXX: We may not put the region control block directly into
	 * the user-provided area, because shared mode requires us to
	 * pull shareable object memory from the main heap. Albeit the
	 * region per se is not shareable between processes, the
	 * syncobj it embeds for synchronization is implicitely
	 * shareable by design (there is no pvsyncobj, which would be
	 * a very seldom use). So we allocate space for the control
	 * block from the main pool instead.
	 */
	rn = xnmalloc(sizeof(*rn));
	if (rn == NULL)
		/*
		 * mmmfff... When error codes are plain silly and we
		 * don't have generic failure codes but braindamage
		 * per-feature errnos to extend the interface, we can
		 * only try to pick the least idiotic value.
		 */
		return ERR_NOSEG;

	/* Skip the unused space. */
	saddr += sizeof(*rn);
	length -= sizeof(*rn);

	CANCEL_DEFER(svc);

	if (name == NULL || *name == '\0')
		sprintf(rn->name, "rn%lu", ++anon_rnids);
	else {
		name = psos_trunc_name(short_name, name);
		namecpy(rn->name, name);
	}

	if (pvcluster_addobj_dup(&psos_rn_table, rn->name, &rn->cobj)) {
		warning("cannot register region: %s", rn->name);
		xnfree(rn);
		ret = ERR_OBJID;
		goto out;
	}

	ret = __heapobj_init(&rn->hobj, name, length, saddr);
	if (ret) {
		pvcluster_delobj(&psos_rn_table, &rn->cobj);
		ret = ERR_TINYRN;
		xnfree(rn);
		goto out;
	}

	if (flags & RN_PRIOR)
		sobj_flags = SYNCOBJ_PRIO;

	rn->length = length;
	rn->usize = usize;	/* Not actually used, just checked. */
	rn->flags = flags;
	rn->busynr = 0;
	rn->usedmem = 0;
	ret = syncobj_init(&rn->sobj, CLOCK_COPPERPLATE, sobj_flags, fnref_null);
	if (ret) {
		heapobj_destroy(&rn->hobj);
		pvcluster_delobj(&psos_rn_table, &rn->cobj);
		xnfree(rn);
		goto out;
	}

	rn->magic = rn_magic;
	*asize_r = rn->hobj.size;
	*rnid_r = mainheap_ref(rn, u_long);
out:
	CANCEL_RESTORE(svc);

	return ret;
}

u_long rn_delete(u_long rnid)
{
	struct syncstate syns;
	struct psos_rn *rn;
	struct service svc;
	int ret;

	rn = get_rn_from_id(rnid, &ret);
	if (rn == NULL)
		return ret;

	CANCEL_DEFER(svc);

	if (syncobj_lock(&rn->sobj, &syns)) {
		ret = ERR_OBJDEL;
		goto out;
	}

	if ((rn->flags & RN_DEL) == 0 && rn->busynr > 0) {
		syncobj_unlock(&rn->sobj, &syns);
		ret = ERR_SEGINUSE;
		goto out;
	}

	pvcluster_delobj(&psos_rn_table, &rn->cobj);
	rn->magic = ~rn_magic; /* Prevent further reference. */
	ret = syncobj_destroy(&rn->sobj, &syns);
	if (ret)
		ret = ERR_TATRNDEL;
	xnfree(rn);
out:
	CANCEL_RESTORE(svc);

	return ret;
}

u_long rn_ident(const char *name, u_long *rnid_r)
{
	struct pvclusterobj *cobj;
	struct psos_rn *rn;
	struct service svc;
	char short_name[5];

	name = psos_trunc_name(short_name, name);

	CANCEL_DEFER(svc);
	cobj = pvcluster_findobj(&psos_rn_table, name);
	CANCEL_RESTORE(svc);
	if (cobj == NULL)
		return ERR_OBJNF;

	rn = container_of(cobj, struct psos_rn, cobj);
	*rnid_r = mainheap_ref(rn, u_long);

	return SUCCESS;
}

u_long rn_getseg(u_long rnid, u_long size, u_long flags,
		 u_long timeout, void **segaddr)
{
	struct psos_rn_wait *wait = NULL;
	struct timespec ts, *timespec;
	struct syncstate syns;
	struct psos_rn *rn;
	struct service svc;
	int ret = SUCCESS;
	void *seg;

	rn = get_rn_from_id(rnid, &ret);
	if (rn == NULL)
		return ret;

	CANCEL_DEFER(svc);

	if (syncobj_lock(&rn->sobj, &syns)) {
		ret = ERR_OBJDEL;
		goto out;
	}

	/*
	 * The heap manager does not enforce any allocation limit; so
	 * we have to do it by ourselves.
	 */
	if (rn->usedmem + size > rn->length)
		goto starve;

	seg = heapobj_alloc(&rn->hobj, size);
	if (seg) {
		*segaddr = seg;
		rn->busynr++;
		rn->usedmem += heapobj_validate(&rn->hobj, seg);
		goto done;
	}

starve:
	if (flags & RN_NOWAIT) {
		ret = ERR_NOSEG;
		goto done;
	}

	if (timeout != 0) {
		timespec = &ts;
		clockobj_ticks_to_timeout(&psos_clock, timeout, timespec);
	} else
		timespec = NULL;

	wait = threadobj_prepare_wait(struct psos_rn_wait);
	wait->ptr = __moff_nullable(NULL);
	wait->size = size;

	ret = syncobj_wait_grant(&rn->sobj, timespec, &syns);
	if (ret == -ETIMEDOUT)
		ret = ERR_TIMEOUT;
	/*
	 * There is no explicit flush operation on pSOS regions,
	 * only an implicit one through deletion.
	 */
	else if (ret == -EIDRM) {
		ret = ERR_RNKILLD;
		goto out;
	}

	*segaddr = __mptr(wait->ptr);
done:
	syncobj_unlock(&rn->sobj, &syns);
out:
	if (wait)
		threadobj_finish_wait();

	CANCEL_RESTORE(svc);

	return ret;
}

u_long rn_retseg(u_long rnid, void *segaddr)
{
	struct threadobj *thobj, *tmp;
	struct psos_rn_wait *wait;
	struct syncstate syns;
	struct psos_rn *rn;
	struct service svc;
	int ret = SUCCESS;
	u_long size;
	void *seg;

	rn = get_rn_from_id(rnid, &ret);
	if (rn == NULL)
		return ret;

	CANCEL_DEFER(svc);

	if (syncobj_lock(&rn->sobj, &syns)) {
		ret = ERR_OBJDEL;
		goto out;
	}

	rn->usedmem -= heapobj_validate(&rn->hobj, segaddr);
	heapobj_free(&rn->hobj, segaddr);
	rn->busynr--;

	if (!syncobj_grant_wait_p(&rn->sobj))
		goto done;

	syncobj_for_each_grant_waiter_safe(&rn->sobj, thobj, tmp) {
		wait = threadobj_get_wait(thobj);
		size = wait->size;
		if (rn->usedmem + size > rn->length)
			continue;
		seg = heapobj_alloc(&rn->hobj, size);
		if (seg) {
			rn->busynr++;
			rn->usedmem += heapobj_validate(&rn->hobj, seg);
			wait->ptr = __moff(seg);
			syncobj_grant_to(&rn->sobj, thobj);
		}
	}
done:
	syncobj_unlock(&rn->sobj, &syns);
out:
	CANCEL_RESTORE(svc);

	return ret;
}