/*
 * Copyright 2004-2008, François Revol, <revol@free.fr>.
 * Distributed under the terms of the MIT License.
 */

#include <malloc.h>
#include <string.h>
#include <KernelExport.h>
#include "vnidpool.h"

#include <stdio.h>

/* primary type for the bitmap */
#define BMT uint32

#define BM_BYTE(p, vnid) (p->bitmap[(vnid % p->bmsize) / sizeof(BMT)])
#define BM_ISSET(p, vnid) (BM_BYTE(p, vnid) & (1 << (p->nextvnid % sizeof(BMT))))
#define BM_SET(p, vnid) (BM_BYTE(p, vnid) |= (1 << (p->nextvnid % sizeof(BMT))))
#define BM_UNSET(p, vnid) (BM_BYTE(p, vnid) &= ~(1 << (p->nextvnid % sizeof(BMT))))

status_t vnidpool_alloc(struct vnidpool **pool, size_t size)
{
	struct vnidpool *p;
	if (size < 2)
		return EINVAL;
	if (!pool)
		return EINVAL;
	size = (size + sizeof(BMT) - 1) / sizeof(BMT);
	size *= sizeof(BMT);
	p = malloc(sizeof(struct vnidpool) + size / sizeof(BMT));
	if (!p)
		return B_NO_MEMORY;
	new_lock(&p->lock, "vnidpool lock");
	p->nextvnid = 1LL;
	p->bitmap = (BMT *)(p + 1);
	p->bmsize = size;
	memset(p->bitmap, 0, size / sizeof(BMT));
	fprintf(stderr, "vnidpool_alloc: pool @ %p, bitmap @ %p, size %ld\n", p, p->bitmap, p->bmsize);
	*pool = p;
	return B_OK;
}

status_t vnidpool_free(struct vnidpool *pool) {
	unsigned int i;
	fprintf(stderr, "vnidpool_free: pool @ %p\n", pool);
	if (!pool)
		return EINVAL;
	if (LOCK(&pool->lock) < B_OK)
		return B_ERROR;
	/* make sure no vnid is left in use */
	for (i = 0; i < (pool->bmsize % sizeof(BMT)); i++) {
		if (pool->bitmap[i])
			fprintf(stderr, "WARNING: vnidpool_free called with vnids still in use!!!\n");
			//panic("vnidpool_free: vnids still in use");
	}
	free_lock(&pool->lock);
	free(pool);
	return B_OK;
}

status_t vnidpool_get(struct vnidpool *pool, ino_t *vnid)
{
	status_t err = B_ERROR;
	uint32 i;
	if (!pool)
		return EINVAL;
	if (LOCK(&pool->lock) < B_OK)
		return B_ERROR;
	for (i = 0; BM_ISSET(pool, pool->nextvnid) && i < pool->bmsize; pool->nextvnid++, i++) {
		/* avoid 0 as vnid */
		if (!pool->nextvnid)
			continue;
	}
	if (BM_ISSET(pool, pool->nextvnid))
		err = ENOBUFS;
	else {
		BM_SET(pool, pool->nextvnid);
		*vnid = pool->nextvnid++;
		err = B_OK;
	}
	UNLOCK(&pool->lock);
	return err;
}

status_t vnidpool_put(struct vnidpool *pool, ino_t vnid)
{
	status_t err = B_ERROR;
	if (!pool)
		return EINVAL;
	if (LOCK(&pool->lock) < B_OK)
		return B_ERROR;
	if (!BM_ISSET(pool, vnid))
		err = EINVAL;
	else {
		BM_UNSET(pool, vnid);
		err = B_OK;
	}
	UNLOCK(&pool->lock);
	return err;
}