#include <colinux/os/alloc.h>#include <colinux/common/libc.h>#include <colinux/os/kernel/filesystem.h>#include <colinux/os/kernel/time.h>#include <asm/errno.h>#include "filesystem.h"#include "monitor.h"#include "transfer.h"static struct co_filesystem_ops flat_mode; /* like UML's hostfs *//* static struct co_filesystem_ops unix_attr_mode; like UML's humfs (TODO) */static co_inode_t *ino_num_to_inode(int ino, co_filesystem_t *filesystem) {	co_inode_t *inode = NULL;	if (ino == 1)		return filesystem->root;        co_list_each_entry(inode, 			   &filesystem->inode_hashes[ino % CO_FS_HASH_TABLE_SIZE],			   hash_node)	{		if (inode->number == ino)			goto out;	}	inode = NULL;out:	return inode;}static co_inode_t *alloc_inode(co_filesystem_t *filesystem, co_inode_t *parent, const char *name) {	co_inode_t *inode;	inode = co_os_malloc(sizeof(*inode));	if (!inode)		return NULL;	co_memset(inode, 0, sizeof(*inode));	do {		inode->number = filesystem->next_inode_num;		filesystem->next_inode_num++;	} while (ino_num_to_inode(inode->number, filesystem) != NULL);	if (parent) {		co_list_add_tail(&inode->node, &parent->sub_inodes);		inode->parent = parent;	}	if (name != NULL) {		int len = co_strlen(name);		char *dup = co_os_malloc(len + 1);		if (!dup) {			co_list_del(&inode->node);			co_os_free(inode);			return NULL;		}		co_memcpy(dup, name, len+1);		inode->name = dup;	}	co_list_init(&inode->sub_inodes);	co_list_add_tail(&inode->flat_node, &filesystem->list_inodes);	co_list_add_tail(&inode->hash_node, &filesystem->inode_hashes[inode->number % CO_FS_HASH_TABLE_SIZE]);	filesystem->inodes_count++;	co_debug_lvl(filesystem, 10, "inode [%d] allocated %p child '%s' of %p",		     filesystem->inodes_count, inode, name ? name : "<root>", parent);		return inode;}static void reparent_inode(co_inode_t *node, co_inode_t *new_parent){	co_list_del(&node->node);	co_list_add_head(&node->node, &new_parent->sub_inodes);	node->parent = new_parent;} static co_inode_t *find_inode(co_filesystem_t *filesystem, co_inode_t *parent, const char *name) {	co_inode_t *inode = NULL;	        co_list_each_entry(inode, &parent->sub_inodes, node) {		if (co_strcmp(inode->name, name) == 0)			return inode;	}	return NULL;}static void free_inode(co_filesystem_t *filesystem, co_inode_t *inode) {	co_list_del(&inode->flat_node);	co_list_del(&inode->hash_node);	if (inode->parent)		co_list_del(&inode->node);	if (inode->names)		co_filesystem_getdir_free(inode->names);	if (inode->name)		co_os_free(inode->name);	co_os_free(inode);	co_debug_lvl(filesystem, 10, "inode [%d] freed %p", filesystem->inodes_count, inode);	filesystem->inodes_count--;}static void free_inode_children(co_filesystem_t *filesystem, co_list_t *delete_now, 				int level, co_list_t *delete_later){	co_inode_t *inode, *inode_new;	if (level > 5) {		co_list_each_entry_safe(inode, inode_new, delete_now, node) {			co_list_del(&inode->node);			co_list_add_head(&inode->node, delete_later);			inode->parent = NULL;		}	} else {		co_list_each_entry_safe(inode, inode_new, delete_now, node) {			free_inode_children(filesystem, &inode->sub_inodes, level + 1, delete_later);			free_inode(filesystem, inode);		}	}}static void free_inode_with_children(co_filesystem_t *filesystem, co_inode_t *inode){	co_list_t to_delete, to_delete_next;		co_list_init(&to_delete);	free_inode_children(filesystem, &inode->sub_inodes, 0, &to_delete);	free_inode(filesystem, inode);	while (!co_list_empty(&to_delete)) {		co_list_init(&to_delete_next);		free_inode_children(filesystem, &to_delete, 0, &to_delete_next);		if (co_list_empty(&to_delete_next))			break;		co_list_init(&to_delete);		free_inode_children(filesystem, &to_delete_next, 0, &to_delete);	}}static co_rc_t inode_forget(co_filesystem_t *filesystem, co_inode_t *inode){	if (inode)		free_inode_with_children(filesystem, inode);	return CO_RC(OK);}static co_rc_t inode_dir_open(co_filesystem_t *filesystem, co_inode_t *inode){	co_rc_t rc;	if (!inode)		return CO_RC(ERROR);	if (inode->names) {		inode->names->refcount++;		return CO_RC(OK);	} 	inode->names = co_os_malloc(sizeof(co_filesystem_dir_names_t));	if (!inode->names)		return CO_RC(OUT_OF_MEMORY);	inode->names->refcount = 1;	co_list_init(&inode->names->list);	rc = filesystem->ops->getdir(filesystem, inode, inode->names);	if (!CO_OK(rc)) {		co_os_free(inode->names);		inode->names = NULL;	}	return rc;}static co_rc_t inode_open(co_filesystem_t *filesystem, co_inode_t *inode, unsigned long flags){	return CO_RC(OK);}static co_rc_t inode_read(co_monitor_t *cmon, co_filesystem_t *filesystem, co_inode_t *inode, 			  unsigned long long offset, unsigned long size,			  vm_ptr_t dest_buffer){	return filesystem->ops->inode_read_write(cmon, filesystem, inode, offset, size, dest_buffer, PTRUE);}static co_rc_t inode_write(co_monitor_t *cmon, co_filesystem_t *filesystem, co_inode_t *inode, 			   unsigned long long offset, unsigned long size,			   vm_ptr_t src_buffer){	return filesystem->ops->inode_read_write(cmon, filesystem, inode, offset, size, src_buffer, PFALSE);}static co_rc_t inode_mknod(co_filesystem_t *filesystem, co_inode_t *dir, unsigned long mode, 			   unsigned long rdev, char *name, int *ino, struct fuse_attr *attr){	co_rc_t rc;	attr->size = 0;	attr->mode = filesystem->file_mode;	attr->nlink = 1;	attr->uid = filesystem->uid;	attr->gid = filesystem->gid;	attr->rdev = 0;	attr->_dummy = 0;	attr->blocks = 0;	attr->atime = \	attr->mtime = \	attr->ctime = co_os_get_time();		rc = filesystem->ops->inode_mknod(filesystem, dir, mode, rdev, name, ino, attr);		if (CO_OK(rc)) {		co_inode_t *inode;		inode = find_inode(filesystem, dir, name);		if (!inode)			inode = alloc_inode(filesystem, dir, name);		*ino = inode->number;	}	return rc;}static co_rc_t inode_mkdir(co_filesystem_t *filesystem, co_inode_t *inode, unsigned long mode, 			   char *name){	return filesystem->ops->inode_mkdir(filesystem, inode, mode, name);}static co_rc_t inode_unlink(co_filesystem_t *filesystem, co_inode_t *inode, char *name){	return filesystem->ops->inode_unlink(filesystem, inode, name);}static co_rc_t inode_rmdir(co_filesystem_t *filesystem, co_inode_t *inode, char *name){	return filesystem->ops->inode_rmdir(filesystem, inode, name);}static co_rc_t inode_set_attr(co_filesystem_t *filesystem, co_inode_t *inode,			      unsigned long valid, struct fuse_attr *attr){	return filesystem->ops->inode_set_attr(filesystem, inode, valid, attr);}static co_rc_t inode_rename(co_filesystem_t *filesystem, co_inode_t *dir,			    int new_dir_num, char *oldname, char *newname){	static co_inode_t *new_dir_inode;	co_rc_t rc;	new_dir_inode = ino_num_to_inode(new_dir_num, filesystem);	if (!new_dir_inode) 		return CO_RC(ERROR);	rc = filesystem->ops->inode_rename(filesystem, dir, new_dir_inode, oldname, newname);	if (CO_OK(rc)) {		co_inode_t *old_inode = find_inode(filesystem, dir, oldname);		if (old_inode)			reparent_inode(old_inode, new_dir_inode);	}	return rc;}static co_rc_t inode_dir_read(co_monitor_t *cmon,			      co_inode_t *inode, 			      vm_ptr_t buff, 			      unsigned long size,			      unsigned long *fill_size,			      unsigned long file_pos){	co_filesystem_name_t *name;	unsigned long file_pos_seek = 0;	struct fuse_dirent dirent;	unsigned long dirent_size;	vm_ptr_t buff_writeptr; 	co_rc_t rc;	if (!inode)		return CO_RC(ERROR);	if (!inode->names)		return CO_RC(ERROR);	buff_writeptr = buff;	*fill_size = 0;        co_list_each_entry(name, &inode->names->list, node) {		int slen = co_strlen(name->name);				dirent_size = FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + slen);		if (file_pos_seek < file_pos) {			file_pos_seek += dirent_size;			continue;		}		if (dirent_size + *fill_size > size) {			/* No space left in buffer */			break;		}		if (co_strcmp(name->name, "..") == 0) {			if (inode->parent)				dirent.ino = inode->parent->number;			else				dirent.ino = inode->number;		} else if (co_strcmp(name->name, ".") == 0) {			dirent.ino = inode->number;		} else {			dirent.ino = -1;		}		/* TODO: Make it dynamicly.  See NAME_MAX in linux kernel. */		if (slen > sizeof(dirent.name)) {			/* Name to long */			co_debug_lvl(filesystem, 5, "name to long (%d) '%s'", slen, name->name);			slen = sizeof(dirent.name);		}		dirent.namelen = slen;		dirent.type = name->type;				co_memcpy(dirent.name, name->name, slen);		rc = co_monitor_host_to_linuxvm(cmon, &dirent, buff_writeptr, dirent_size);		if (!CO_OK(rc))			return rc;				buff_writeptr += dirent_size;		*fill_size += dirent_size;		file_pos_seek += dirent_size;	}	return CO_RC(OK);}static co_rc_t inode_dir_release(co_inode_t *inode){	if (!inode) {		return CO_RC(ERROR);	}	if (!inode->names)		return CO_RC(ERROR);	inode->names->refcount--;	if (inode->names->refcount > 0) 		return CO_RC(OK);	co_filesystem_getdir_free(inode->names);	inode->names = NULL;	return CO_RC(OK);}void co_filesystem_getdir_free(co_filesystem_dir_names_t *names){	co_filesystem_name_t *name;	while (!co_list_empty(&names->list)) {		co_list_entry_assign(names->list.next, name, node);		co_list_del(&name->node);		co_os_free(name);	}}co_rc_t co_monitor_file_system_init(co_monitor_t *cmon, unsigned int unit,				    co_cofsdev_desc_t *desc){	co_filesystem_t *filesystem;	int i;	filesystem = co_os_malloc(sizeof(*filesystem));	if (!filesystem)		return CO_RC(OUT_OF_MEMORY);	co_memset(filesystem, 0, sizeof(*filesystem));	for (i=0; i < CO_FS_HASH_TABLE_SIZE; i++) {		co_list_init(&filesystem->inode_hashes[i]);	}	filesystem->next_inode_num = 1;	co_list_init(&filesystem->list_inodes);	co_memcpy(&filesystem->base_path, &desc->pathname, sizeof(co_pathname_t));	filesystem->desc = desc;	filesystem->ops = &flat_mode; /* The only supported mode at the moment */	filesystem->root = alloc_inode(filesystem, NULL, NULL);	if (!filesystem->root) {		co_os_free(filesystem);		return CO_RC(OUT_OF_MEMORY);	}	cmon->filesystems[unit] = filesystem;			return CO_RC(OK);}void co_monitor_file_system_free(co_monitor_t *cmon, int unit){	co_filesystem_t *filesystem = cmon->filesystems[unit];	co_inode_t *inode;