/* inode->vnode table */

struct vinotab;

struct vinoent {
	LIST_ENTRY(vinoent)	vie_entry;
};

struct vinoparam {
	ptrdiff_t	vip_vnoff;
	ptrdiff_t	vip_inoff;
};

struct vinotab *
	vinotab_create(struct vinoparam);
void	vinotab_destroy(struct vfs_inode_table *);
int	vinotab_get(struct vinotab *, ino_t, int, struct vnode **);
int	vinotab_intern(struct vinotab *, struct vinoent *, int,
	    struct vnode **);
void	vinotab_remove(struct vinotab *, struct vinoent *);

/*
 * Hash tables are a bad idea, but they're what we've been using all
 * along, so we might as well take advantage of them for pserialized
 * access until we get a better pserializable data structure.
 */

LIST_HEAD(vinohead, vinoent);

struct vinotab {
	kmutex_t		vit_lock;
	kcondvar_t		vit_cv;
	pserialize_t		vit_psz;
	struct vinohashtab {
		struct vinohead		*vih_buckets;
		unsigned long		vih_mask;
	}			*vit_hashtab;
	struct vinoparam	vit_param;
};

static ino_t
vinoent_ino(const struct vinotab *inotab, const struct vinoent *inoent)
{
	const char *const p = (const void *)inoent;

	return *(const ino_t *)(p + inotab->vit_param.vip_inoff);
}

static struct vnode *
vinoent_vp(const struct vinotab *inotab, const struct vinoent *inoent)
{
	const char *const p = (const void *)inoent;

	return *(struct vnode *const *)(p + inotab->vit_param.vip_vnoff);
}

static size_t
vinohash(struct vinohashtab *inohash, ino_t ino)
{

	return (ino & inohash->vih_mask);
}

struct vinotab *
vinotab_create(struct vinoparam param)
{
	struct vinotab *const inotab = kmem_alloc(sizeof(*inotab), KM_SLEEP);

	mutex_init(&inotab->vit_lock, MUTEX_DEFAULT, IPL_NONE);
	cv_init(&inotab->vit_cv, "vrehash");
	inotab->vit_psz = pserialize_create();
	inotab->vit_hash = kmem_alloc(sizeof(*inotab->vit_hash), KM_SLEEP);
	/* XXX desiredvnodes strikes me as overkill for one fs.  */
	inotab->vit_hash->vih_buckets = hashinit(desiredvnodes, HASH_LIST,
	    true, &inotab->vit_hash->vih_mask);
	inotab->vit_param = param;
}

void
vinotab_destroy(struct vinotab *inotab)
{

#if DIAGNOSTIC
    {
	size_t i;
	for (i = 0; i <= inotab->vit_hashmask; i++)
		KASSERT(LIST_EMPTY(&inotab->vit_buckets[i]));
    }
#endif

	hashdone(inotab->vit_hashtab->vih_buckets, HASH_LIST,
	    inotab->vit_hashtab->vih_mask);
	kmem_free(inotab->vit_hashtab, sizeof(*inotab->vit_hashtab));
	pserialize_destroy(inotab->vit_psz);
	cv_destroy(&inotab->vit_cv);
	mutex_destroy(&inotab->vit_lock);
	kmem_free(inotab, sizeof(*inotab));
}

void
vinotab_reinit(struct vinotab *inotab)
{
	struct vinohashtab *oldhashtab, *newhashtab;
	struct vinohead *oldbuckets, *newbuckets;
	struct vinoentry *inoent, *next;
	size_t hash;
	size_t i;

	newhashtab = kmem_alloc(sizeof(*newhashtab), KM_SLEEP);
	newhashtab->vih_buckets = hashinit(desiredvnodes, HASH_LIST, true,
	    &newhashtab->vih_mask);
	newbuckets = newhashtab->vih_buckets;

	mutex_enter(&inotab->vit_lock);
	oldhashtab = inotab->vit_hash;
	oldbuckets = oldhashtab->vih_buckets;
	inotab->vit_hash = NULL;
	pserialize_perform(inotab->vit_psz);
	for (i = 0; i <= oldhashtab->vih_mask; i++) {
		LIST_FOREACH_SAFE(inoent, &oldbuckets[i], vie_entry, next) {
			LIST_REMOVE(inoent, vie_entry);
			hash = vinohash(inotab, vinoent_ino(inotab, inoent));
			LIST_INSERT_HEAD(&newbuckets[hash], inoent, vie_entry);
		}
	}
	membar_producer();
	inotab->vit_hash = newhashtab;
	cv_broadcast(&inotab->vit_cv, &inotab->vit_lock);
	mutex_exit(&inotab->vit_lock);

	hashdone(oldbuckets, HASH_LIST, oldhashtab->vih_mask);
	kmem_free(oldhashtab, sizeof(*oldhashtab));
}

static int
vinotab_wait(struct vinotab *inotab, int flags)
{
	int error = 0;

	KASSERT(mutex_owned(&inotab->vit_lock));
	while (inotab->vit_hashtab == NULL) {
		if (flags == VGET_NONBLOCK) {
			return EWOULDBLOCK;
		} else if (flags == VGET_INTR) {
			error = cv_wait_sig(&inotab->vit_cv,
			    &inotab->vit_lock);
			if (error)
				return error;
		} else {
			cv_wait(&inotab->vit_cv, &inotab->vit_lock);
		}
	}

	return 0;
}

int
vinotab_get(struct vinotab *inotab, ino_t ino, int flags, struct vnode **vpp)
{
	struct vinohashtab *hashtab;
	struct vinohead *head;
	struct vinoent *inoent;
	struct vnode *vp = NULL;
	int s, error;

	s = pserialize_read_enter();
	hashtab = inotab->vit_hashtab;
	if (hashtab == NULL) {
		pserialize_read_exit(s);
		mutex_enter(&inotab->vit_lock);
		error = vinotab_wait(inotab);
		if (error) {
			mutex_exit(&inotab->vit_lock);
			return error;
		}
		hashtab = inotab->vit_hashtab;
		KASSERT(hashtab != NULL);
		s = pserialize_read_enter(s);
		mutex_exit(&inotab->vit_lock);
	} else {
		membar_consumer();	/* XXX membar_datadep_consumer */
	}
	head = &hashtab->vih_buckets[vinohash(hashtab, ino)];
	LIST_FOREACH(inoent, head, vie_entry) {
		membar_consumer();	/* XXX membar_datadep_consumer */
		if (ino != vinoent_ino(inotab, inoent))
			continue;

		vp = vinoent_vp(inotab, inoent);
		vpreget(vp);
		pserialize_read_exit(s);

		error = vget(vp, flags);
		if (error)
			goto fail;

		*vpp = vp;
		return 0;
	}
	pserialize_read_exit(s);

	error = ENOENT;
fail:	KASSERT(error);
	*vpp = NULL;
	return error;
}

int
vinotab_intern(struct vinotab *inotab, struct vinoent *new_inoent, int flags,
    struct vnode **vpp)
{
	const ino_t ino = vinoent_ino(inotab, new_inoent);
	struct vinohashtab *hashtab;
	struct vinohead *head;
	struct vinoent *inoent;
	struct vnode *vp0;
	int error;

retry:	mutex_enter(&inotab->vit_lock);
	hashtab = inotab->vit_hashtab;
	head = &hashtab->vih_buckets[vinohash(hashtab, ino)];
	LIST_FOREACH(inoent, head, vie_entry) {
		if (ino != vinoent_ino(inotab, inoent))
			continue;

		vp0 = vinoent_vp(inotab, inoent);
		vpreget(vp0);
		mutex_exit(&inotab->vit_lock);

		error = vget(vp0, flags);
		if (error) {
			if (error == ENOENT)
				goto retry;
			vp0 = NULL;
			goto out;
		}
		goto out;
	}

	vp0 = vinoent_vp(inotab, inoent);
	vnode_initializing(vp0);
	membar_producer();
	LIST_INSERT_HEAD(head, new_inoent, vie_entry);
	mutex_exit(&inotab->vit_lock);

	error = 0;

out:	*vpp = vp0;
	return error;
}

void
vinotab_remove(struct vinotab *inotab, struct vinoent *inoent)
{

	mutex_enter(&inotab->vit_lock);
	LIST_REMOVE(inoent, vie_entry);
	pserialize_perform(inotab->vit_psz);
	mutex_exit(&inotab->vit_lock);
}