/* VTreeFS - inode.c - by Alen Stojanov and David van Moolenbroek */

#include "inc.h"

/* The number of inodes and hash table slots. */
PRIVATE unsigned int nr_inodes;

/* The table of all the inodes. */
PRIVATE struct inode *inode;

/* The list of unused inodes. */
PRIVATE TAILQ_HEAD(unused_head, inode) unused_inodes;

/* The hash tables for lookup of <parent,name> and <parent,index> to inode. */
PRIVATE LIST_HEAD(name_head, inode) *parent_name_head;
PRIVATE LIST_HEAD(index_head, inode) *parent_index_head;

/* Internal integrity check. */
#define CHECK_INODE(node)						\
	do {								\
		assert(node >= &inode[0] && node < &inode[nr_inodes]);	\
		assert(node == &inode[0] ||				\
			node->i_parent != NULL ||			\
			(node->i_flags & I_DELETED));			\
	} while (0);

/*===========================================================================*
 *				init_inodes				     *
 *===========================================================================*/
PUBLIC void init_inodes(unsigned int inodes, struct inode_stat *stat,
	index_t nr_indexed_entries)
{
	/* Initialize the inode-related state.
	 */
	struct inode *node;
	int i;

	assert(inodes > 0);
	assert(nr_indexed_entries >= 0);

	nr_inodes = inodes;

	/* Allocate the inode and hash tables. */
	inode = malloc(nr_inodes * sizeof(inode[0]));
	parent_name_head = malloc(nr_inodes * sizeof(parent_name_head[0]));
	parent_index_head = malloc(nr_inodes * sizeof(parent_index_head[0]));

	assert(inode != NULL);
	assert(parent_name_head != NULL);
	assert(parent_index_head != NULL);

#if DEBUG
	printf("VTREEFS: allocated %d+%d+%d bytes\n",
		nr_inodes * sizeof(inode[0]),
		nr_inodes * sizeof(parent_name_head[0]),
		nr_inodes * sizeof(parent_index_head[0]));
#endif

	/* Initialize the free/unused list. */
	TAILQ_INIT(&unused_inodes);

	/* Add free inodes to the unused/free list. Skip the root inode. */
	for (i = 1; i < nr_inodes; i++) {
		node = &inode[i];

		node->i_parent = NULL;
		node->i_count = 0;
		TAILQ_INIT(&node->i_children);
		TAILQ_INSERT_HEAD(&unused_inodes, node, i_unused);
	}

	/* Initialize the hash lists. */
	for (i = 0; i < nr_inodes; i++) {
		LIST_INIT(&parent_name_head[i]);
		LIST_INIT(&parent_index_head[i]);
	}

	/* Initialize the root inode. */
	node = &inode[0];
	node->i_parent = NULL;
	node->i_count = 0;
	TAILQ_INIT(&node->i_children);
	node->i_flags = 0;
	node->i_index = NO_INDEX;
	set_inode_stat(node, stat);
	node->i_indexed = nr_indexed_entries;
	node->i_cbdata = NULL;
}

/*===========================================================================*
 *				cleanup_inodes				     *
 *===========================================================================*/
PUBLIC void cleanup_inodes(void)
{
	/* Clean up the inode-related state.
	 */

	/* Free the inode and hash tables. */
	free(parent_index_head);
	free(parent_name_head);
	free(inode);
}

/*===========================================================================*
 *				parent_name_hash			     *
 *===========================================================================*/
PRIVATE int parent_name_hash(struct inode *parent, char *name)
{
	/* Return the hash value of <parent,name> tuple.
	 */
	unsigned int name_hash;
	unsigned long parent_hash;

	/* The parent hash is a simple array entry; find its index. */
	parent_hash = parent - &inode[0];

	/* Use the sdbm algorithm to hash the name. */
	name_hash = sdbm_hash(name, strlen(name));

	return (parent_hash ^ name_hash) % nr_inodes;
}

/*===========================================================================*
 *				parent_index_hash			     *
 *===========================================================================*/
PRIVATE int parent_index_hash(struct inode *parent, index_t index)
{
	/* Return the hash value of a <parent,index> tuple.
	 */

	return ((parent - &inode[0]) ^ index) % nr_inodes;
}

/*===========================================================================*
 *				purge_inode				     *
 *===========================================================================*/
PUBLIC void purge_inode(struct inode *parent)
{
	/* Delete a deletable inode to make room for a new inode.
	 */
	/* An inode is deletable if:
	 * - it is in use;
	 * - it is indexed;
	 * - it is not the given parent inode;
	 * - it has a zero reference count;
	 * - it does not have any children.
	 * The first point is true for all inodes, or we would not be here.
	 * The latter two points also imply that I_DELETED is not set.
	 */
	static int last_checked = 0;
	struct inode *node;
	int count;

	assert(TAILQ_EMPTY(&unused_inodes));

	/* This should not happen often enough to warrant an extra linked list,
	 * especially as maintenance of that list would be rather error-prone..
	 */
	for (count = 0; count < nr_inodes; count++) {
		node = &inode[last_checked];
		last_checked = (last_checked + 1) % nr_inodes;

		if (node != parent && node->i_index != NO_INDEX &&
			node->i_count == 0 && TAILQ_EMPTY(&node->i_children)) {

			assert(!(node->i_flags & I_DELETED));

			delete_inode(node);

			break;
		}
	}
}

/*===========================================================================*
 *				add_inode				     *
 *===========================================================================*/
PUBLIC struct inode *add_inode(struct inode *parent, char *name,
	index_t index, struct inode_stat *stat, index_t nr_indexed_entries,
	cbdata_t cbdata)
{
	/* Add an inode.
	 */
	struct inode *newnode;
	int slot;

	CHECK_INODE(parent);
	assert(S_ISDIR(parent->i_stat.mode));
	assert(!(parent->i_flags & I_DELETED));
	assert(strlen(name) <= PNAME_MAX);
	assert(index >= 0 || index == NO_INDEX);
	assert(stat != NULL);
	assert(nr_indexed_entries >= 0);
	assert(get_inode_by_name(parent, name) == NULL);

	/* Get a free inode. Free one up if necessary. */
	if (TAILQ_EMPTY(&unused_inodes))
		purge_inode(parent);

	assert(!TAILQ_EMPTY(&unused_inodes));

	newnode = TAILQ_FIRST(&unused_inodes);
	TAILQ_REMOVE(&unused_inodes, newnode, i_unused);

	assert(newnode->i_count == 0);

	/* Copy the relevant data to the inode. */
	newnode->i_parent = parent;
	newnode->i_flags = 0;
	newnode->i_index = index;
	newnode->i_stat = *stat;
	newnode->i_indexed = nr_indexed_entries;
	newnode->i_cbdata = cbdata;
	strcpy(newnode->i_name, name);

	/* Add the inode to the list of children inodes of the parent. */
	TAILQ_INSERT_HEAD(&parent->i_children, newnode, i_siblings);

	/* Add the inode to the <parent,name> hash table. */
	slot = parent_name_hash(parent, name);
	LIST_INSERT_HEAD(&parent_name_head[slot], newnode, i_hname);

	/* Add the inode to the <parent,index> hash table. */
	if (index != NO_INDEX) {
		slot = parent_index_hash(parent, index);
		LIST_INSERT_HEAD(&parent_index_head[slot], newnode, i_hindex);
	}

	return newnode;
}

/*===========================================================================*
 *				get_root_inode				     *
 *===========================================================================*/
PUBLIC struct inode *get_root_inode(void)
{
	/* Return the file system's root inode.
	 */

	/* The root node is always the first node in the inode table */
	return &inode[0];
}

/*===========================================================================*
 *				get_inode_name				     *
 *===========================================================================*/
PUBLIC char const *get_inode_name(struct inode *node)
{
	/* Return the name that an inode has in its parent directory.
	 */

	CHECK_INODE(node);

	return node->i_name;
}

/*===========================================================================*
 *				get_inode_index				     *
 *===========================================================================*/
PUBLIC index_t get_inode_index(struct inode *node)
{
	/* Return the index that an inode has in its parent directory.
	 */

	CHECK_INODE(node);

	return node->i_index;
}

/*===========================================================================*
 *				get_inode_cbdata			     *
 *===========================================================================*/
PUBLIC cbdata_t get_inode_cbdata(struct inode *node)
{
	/* Return the callback data associated with the given inode.
	 */

	CHECK_INODE(node);

	return node->i_cbdata;
}

/*===========================================================================*
 *				get_parent_inode			     *
 *===========================================================================*/
PUBLIC struct inode *get_parent_inode(struct inode *node)
{
	/* Return an inode's parent inode.
	 */

	CHECK_INODE(node);

	/* The root inode does not have parent. */
	if (node == &inode[0])
		return NULL;

	return node->i_parent;
}

/*===========================================================================*
 *				get_first_inode				     *
 *===========================================================================*/
PUBLIC struct inode *get_first_inode(struct inode *parent)
{
	/* Return a directory's first (non-deleted) child inode.
	 */
	struct inode *node;

	CHECK_INODE(parent);
	assert(S_ISDIR(parent->i_stat.mode));

	node = TAILQ_FIRST(&parent->i_children);

	while (node != NULL && (node->i_flags & I_DELETED))
		node = TAILQ_NEXT(node, i_siblings);

	return node;
}

/*===========================================================================*
 *				get_next_inode				     *
 *===========================================================================*/
PUBLIC struct inode *get_next_inode(struct inode *previous)
{
	/* Return a directory's next (non-deleted) child inode.
	 */
	struct inode *node;

	CHECK_INODE(previous);

	node = TAILQ_NEXT(previous, i_siblings);

	while (node != NULL && (node->i_flags & I_DELETED))
		node = TAILQ_NEXT(node, i_siblings);

	return node;
}

/*===========================================================================*
 *				get_inode_number			     *
 *===========================================================================*/
PUBLIC int get_inode_number(struct inode *node)
{
	/* Return the inode number of the given inode.
	 */

	CHECK_INODE(node);

	return (int) (node - &inode[0]) + 1;
}

/*===========================================================================*
 *				get_inode_stat				     *
 *===========================================================================*/
PUBLIC void get_inode_stat(struct inode *node, struct inode_stat *stat)
{
	/* Retrieve an inode's status.
	 */

	CHECK_INODE(node);

	*stat = node->i_stat;
}

/*===========================================================================*
 *				set_inode_stat				     *
 *===========================================================================*/
PUBLIC void set_inode_stat(struct inode *node, struct inode_stat *stat)
{
	/* Set an inode's status.
	 */

	CHECK_INODE(node);

	node->i_stat = *stat;
}

/*===========================================================================*
 *				get_inode_by_name			     *
 *===========================================================================*/
PUBLIC struct inode *get_inode_by_name(struct inode *parent, char *name)
{
	/* Look up an inode using a <parent,name> tuple.
	 */
	struct inode *node;
	int slot;

	CHECK_INODE(parent);
	assert(strlen(name) <= PNAME_MAX);
	assert(S_ISDIR(parent->i_stat.mode));

	/* Get the hash value, and search for the inode. */
	slot = parent_name_hash(parent, name);
	LIST_FOREACH(node, &parent_name_head[slot], i_hname) {
		if (parent == node->i_parent && !strcmp(name, node->i_name))
			return node;	/* found */
	}

	return NULL;
}

/*===========================================================================*
 *				get_inode_by_index			     *
 *===========================================================================*/
PUBLIC struct inode *get_inode_by_index(struct inode *parent, index_t index)
{
	/* Look up an inode using a <parent,index> tuple.
	 */
	struct inode *node;
	int slot;

	CHECK_INODE(parent);
	assert(S_ISDIR(parent->i_stat.mode));
	assert(index >= 0 && index < parent->i_indexed);

	/* Get the hash value, and search for the inode. */
	slot = parent_index_hash(parent, index);
	LIST_FOREACH(node, &parent_index_head[slot], i_hindex) {
		if (parent == node->i_parent && index == node->i_index)
			return node;	/* found */
	}

	return NULL;
}

/*===========================================================================*
 *				find_inode				     *
 *===========================================================================*/
PUBLIC struct inode *find_inode(ino_t num)
{
	/* Retrieve an inode by inode number.
	 */
	struct inode *node;

	node = &inode[num - 1];

	CHECK_INODE(node);

	return node;
}

/*===========================================================================*
 *				get_inode				     *
 *===========================================================================*/
PUBLIC struct inode *get_inode(ino_t num)
{
	/* Retrieve an inode by inode number, and increase its reference count.
	 */
	struct inode *node;

	if ((node = find_inode(num)) == NULL)
		return NULL;

	node->i_count++;
	return node;
}

/*===========================================================================*
 *				put_inode				     *
 *===========================================================================*/
PUBLIC void put_inode(struct inode *node)
{
	/* Decrease an inode's reference count.
	 */

	CHECK_INODE(node);
	assert(node->i_count > 0);

	node->i_count--;

	/* If the inode is scheduled for deletion, and has no more references,
	 * actually delete it now.
	 */
	if ((node->i_flags & I_DELETED) && node->i_count == 0)
		delete_inode(node);
}

/*===========================================================================*
 *				ref_inode				     *
 *===========================================================================*/
PUBLIC void ref_inode(struct inode *node)
{
	/* Increase an inode's reference count.
	 */

	CHECK_INODE(node);
	assert(node->i_count >= 0);

	node->i_count++;
}

/*===========================================================================*
 *				unlink_inode				     *
 *===========================================================================*/
PRIVATE void unlink_inode(struct inode *node)
{
	/* Unlink the given node from its parent, if it is still linked in.
	 */
	struct inode *parent;

	assert(node->i_flags & I_DELETED);

	parent = node->i_parent;
	if (parent == NULL)
		return;

	/* Delete the node from the parent list. */
	node->i_parent = NULL;

	TAILQ_REMOVE(&parent->i_children, node, i_siblings);

	/* Optionally recheck if the parent can now be deleted. */
	if (parent->i_flags & I_DELETED)
		delete_inode(parent);
}

/*===========================================================================*
 *				delete_inode				     *
 *===========================================================================*/
PUBLIC void delete_inode(struct inode *node)
{
	/* Delete the given inode. If its reference count is nonzero, or it
	 * still has children that cannot be deleted for the same reason, keep
	 * the inode around for the time being. If the node is a directory,
	 * keep around its parent so that we can still do a "cd .." out of it.
	 * For these reasons, this function may be called on an inode more than
	 * once before it is actually deleted.
	 */
	struct inode *cnode, *ctmp;

	CHECK_INODE(node);
	assert(node != &inode[0]);

	/* If the inode was not already scheduled for deletion,
	 * partially remove the node.
	 */
	if (!(node->i_flags & I_DELETED)) {
		/* Remove any children first (before I_DELETED is set!). */
		TAILQ_FOREACH_SAFE(cnode, &node->i_children, i_siblings, ctmp)
			delete_inode(cnode);

		/* Unhash the inode from the <parent,name> table. */
		LIST_REMOVE(node, i_hname);

		/* Unhash the inode from the <parent,index> table if needed. */
		if (node->i_index != NO_INDEX)
			LIST_REMOVE(node, i_hindex);

		node->i_flags |= I_DELETED;

		/* If this inode is not a directory, we don't care about being
		 * able to find its parent. Unlink it from the parent now.
		 */
		if (!S_ISDIR(node->i_stat.mode))
			unlink_inode(node);
	}

	if (node->i_count == 0 && TAILQ_EMPTY(&node->i_children)) {
		/* If this inode still has a parent at this point, unlink it
		 * now; noone can possibly refer to it anymore.
		 */
		if (node->i_parent != NULL)
			unlink_inode(node);

		/* Delete the actual node. */
		TAILQ_INSERT_HEAD(&unused_inodes, node, i_unused);
	}
}

/*===========================================================================*
 *				is_inode_deleted			     *
 *===========================================================================*/
PUBLIC int is_inode_deleted(struct inode *node)
{
	/* Return whether the given inode has been deleted.
	 */

	return (node->i_flags & I_DELETED);
}

/*===========================================================================*
 *				fs_putnode				     *
 *===========================================================================*/
PUBLIC int fs_putnode(void)
{
	/* Find the inode specified by the request message, and decrease its
	 * reference count.
	 */
	struct inode *node;

	/* Get the inode specified by its number. */
	if ((node = find_inode(fs_m_in.REQ_INODE_NR)) == NULL)
		return EINVAL;

	/* Decrease the reference count. */
	node->i_count -= fs_m_in.REQ_COUNT - 1;

	assert(node->i_count > 0);

	put_inode(node);

	return OK;
}
