/*
 * 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 <boilerplate/lock.h>
#include <copperplate/cluster.h>
#include <psos/psos.h>
#include "internal.h"
#include "pt.h"

#define pt_magic	0x8181fefe

#define pt_align_mask   (sizeof(void *)-1)

#define pt_bitmap_pos(pt,n) \
pt->bitmap[((n) / (sizeof(u_long) * 8))]

#define pt_block_pos(n) \
(1L << ((n) % (sizeof(u_long) * 8)))

#define pt_bitmap_setbit(pt,n) \
(pt_bitmap_pos(pt,n) |= pt_block_pos(n))

#define pt_bitmap_clrbit(pt,n) \
(pt_bitmap_pos(pt,n) &= ~pt_block_pos(n))

#define pt_bitmap_tstbit(pt,n) \
(pt_bitmap_pos(pt,n) & pt_block_pos(n))

struct pvcluster psos_pt_table;

static unsigned long anon_ptids;

/*
 * XXX: Status wrt caller cancellation: all these routines are not
 * supposed to traverse any cancellation point (*), so we don't bother
 * adding any cleanup handler to release the partition lock, given
 * that copperplate-protected sections disables asynchronous thread
 * cancellation temporarily and therefore will allow callees to grab
 * mutexes safely.
 *
 * (*) all private cluster management routines are expected to be free
 * from cancellation points. You have been warned.
 */

static struct psos_pt *get_pt_from_id(u_long ptid, int *err_r)
{
	struct psos_pt *pt = (struct psos_pt *)ptid;

	/*
	 * Unlike most other pSOS objects (except timers), the
	 * partition control block is NOT laid into the main heap, so
	 * don't have to apply mainheap_deref() to convert partition
	 * handles to pointers, but we do a plain cast instead.  (This
	 * said, mainheap_deref() is smart enough to deal with private
	 * pointers, but we just avoid useless overhead).
	 */
	if (pt == NULL || ((uintptr_t)pt & (sizeof(uintptr_t)-1)) != 0)
		goto objid_error;

	if (pt->magic == pt_magic) {
		if (__RT(pthread_mutex_lock(&pt->lock)) == 0) {
			if (pt->magic == pt_magic)
				return pt;
			__RT(pthread_mutex_unlock(&pt->lock));
			/* Will likely fall down to ERR_OBJDEL. */
		}
	}

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

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

objid_error:
	*err_r = ERR_OBJID;

	return NULL;
}

static inline void put_pt(struct psos_pt *pt)
{
	__RT(pthread_mutex_unlock(&pt->lock));
}

static inline size_t pt_overhead(size_t psize, size_t bsize)
{
	size_t m = (bsize * 8);
	size_t q = ((psize - sizeof(struct psos_pt)) * m) / (m + 1);
	return (psize - q + pt_align_mask) & ~pt_align_mask;
}

u_long pt_create(const char *name,
		 void *paddr, void *laddr  __attribute__ ((unused)),
		 u_long psize, u_long bsize, u_long flags,
		 u_long *ptid_r, u_long *nbuf)
{
	pthread_mutexattr_t mattr;
	char short_name[5];
	struct service svc;
	struct psos_pt *pt;
	int ret = SUCCESS;
	u_long overhead;
	caddr_t mp;
	u_long n;

	if ((uintptr_t)paddr & (sizeof(uintptr_t) - 1))
		return ERR_PTADDR;

	if (bsize <= pt_align_mask)
		return ERR_BUFSIZE;

	if (bsize & (bsize - 1))
		return ERR_BUFSIZE;	/* Not a power of two. */

	if (psize < sizeof(*pt))
		return ERR_TINYPT;

	pt = paddr;

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

	CANCEL_DEFER(svc);

	if (pvcluster_addobj_dup(&psos_pt_table, pt->name, &pt->cobj)) {
		warning("cannot register partition: %s", pt->name);
		ret = ERR_OBJID;
		goto out;
	}

	pt->flags = flags;
	pt->bsize = (bsize + pt_align_mask) & ~pt_align_mask;
	overhead = pt_overhead(psize, pt->bsize);

	pt->nblks = (psize - overhead) / pt->bsize;
	if (pt->nblks == 0) {
		ret = ERR_TINYPT;
		goto out;
	}

	pt->psize = pt->nblks * pt->bsize;
	pt->data = (caddr_t)pt + overhead;
	pt->freelist = mp = pt->data;
	pt->ublks = 0;

	for (n = pt->nblks; n > 1; n--) {
		caddr_t nmp = mp + pt->bsize;
		*((void **)mp) = nmp;
		mp = nmp;
	}

	*((void **)mp) = NULL;
	memset(pt->bitmap, 0, overhead - sizeof(*pt) + sizeof(pt->bitmap));
	*nbuf = pt->nblks;

	pthread_mutexattr_init(&mattr);
	pthread_mutexattr_settype(&mattr, mutex_type_attribute);
	pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_INHERIT);
	pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_PRIVATE);
	__RT(pthread_mutex_init(&pt->lock, &mattr));
	pthread_mutexattr_destroy(&mattr);

	pt->magic = pt_magic;
	*ptid_r = (u_long)pt;
out:
	CANCEL_RESTORE(svc);

	return ret;
}

u_long pt_delete(u_long ptid)
{
	struct psos_pt *pt;
	struct service svc;
	int ret;

	pt = get_pt_from_id(ptid, &ret);
	if (pt == NULL)
		return ret;

	if ((pt->flags & PT_DEL) == 0 && pt->ublks > 0) {
		put_pt(pt);
		return ERR_BUFINUSE;
	}

	CANCEL_DEFER(svc);
	pvcluster_delobj(&psos_pt_table, &pt->cobj);
	CANCEL_RESTORE(svc);
	pt->magic = ~pt_magic; /* Prevent further reference. */
	put_pt(pt);
	__RT(pthread_mutex_destroy(&pt->lock));

	return SUCCESS;
}

u_long pt_getbuf(u_long ptid, void **bufaddr)
{
	struct psos_pt *pt;
	u_long numblk;
	void *buf;
	int ret;

	pt = get_pt_from_id(ptid, &ret);
	if (pt == NULL)
		return ret;

	buf = pt->freelist;
	if (buf) {
		pt->freelist = *((void **)buf);
		pt->ublks++;
		numblk = ((caddr_t)buf - pt->data) / pt->bsize;
		pt_bitmap_setbit(pt, numblk);
	}

	put_pt(pt);

	*bufaddr = buf;
	if (buf == NULL)
		return ERR_NOBUF;

	return SUCCESS;
}

u_long pt_retbuf(u_long ptid, void *buf)
{
	struct psos_pt *pt;
	u_long numblk;
	int ret;

	pt = get_pt_from_id(ptid, &ret);
	if (pt == NULL)
		return ret;

	if ((caddr_t)buf < pt->data ||
	    (caddr_t)buf >= pt->data + pt->psize ||
	    (((caddr_t)buf - pt->data) % pt->bsize) != 0) {
		ret = ERR_BUFADDR;
		goto done;
	}

	numblk = ((caddr_t)buf - pt->data) / pt->bsize;

	if (!pt_bitmap_tstbit(pt, numblk)) {
		ret = ERR_BUFFREE;
		goto done;
	}

	pt_bitmap_clrbit(pt, numblk);
	*((void **)buf) = pt->freelist;
	pt->freelist = buf;
	pt->ublks--;
	ret = SUCCESS;
done:
	put_pt(pt);

	return ret;
}

u_long pt_ident(const char *name, u_long node, u_long *ptid_r)
{
	struct pvclusterobj *cobj;
	struct service svc;
	struct psos_pt *pt;
	char short_name[5];

	if (node)
		return ERR_NODENO;

	name = psos_trunc_name(short_name, name);

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

	pt = container_of(cobj, struct psos_pt, cobj);
	*ptid_r = (u_long)pt;

	return SUCCESS;
}