filesystem.c

一个Windows下的Linux专用虚拟机

	if (!filesystem)
		return;

	while (!co_list_empty(&filesystem->list_inodes)) {		
		co_list_entry_assign(filesystem->list_inodes.next, inode, flat_node);
		free_inode(filesystem, inode);
	}

	co_os_free(filesystem);
	cmon->filesystems[unit] = NULL;
}

static co_rc_t inode_get_attr(co_filesystem_t *filesystem, co_inode_t *inode, 
			      struct fuse_getattr_out *attr)
{
	char *name;

	name = inode->name;
	inode = inode->parent;

	if (name == NULL)
		name = "";

	return filesystem->ops->getattr(filesystem, inode, name, &attr->attr);
}

static co_rc_t inode_lookup(co_filesystem_t *filesystem, co_inode_t *dir, 
			    char *name, struct fuse_lookup_out *args)
{
	co_rc_t rc = filesystem->ops->getattr(filesystem, dir, name, &args->attr);

	if (CO_OK(rc)) {
		co_inode_t *inode = NULL;
		inode = find_inode(filesystem, dir, name);
		if (!inode)
			inode = alloc_inode(filesystem, dir, name);
		args->ino = inode->number;
	}

	return rc;
}

static int translate_code(co_rc_t value)
{
	switch (CO_RC_GET_CODE(value)) {
	case CO_RC_NOT_FOUND:
		return -ENOENT;
	case CO_RC_ACCESS_DENIED:
		return -EPERM;
	case CO_RC_INVALID_PARAMETER:
		return -EINVAL;
	case 0:
		return 0;
	default:
		return -EIO;
	}
	return 0;
}

static co_rc_t fs_mount(co_filesystem_t *filesystem, const char *pathname,
			int uid, int gid, unsigned long dir_mode, 
			unsigned long file_mode)
{	
	co_cofsdev_desc_t *desc;
	co_rc_t rc;

	desc = filesystem->desc;

	filesystem->uid = uid;
	filesystem->gid = gid;
	filesystem->dir_mode = dir_mode;
	filesystem->file_mode = file_mode;

	co_memcpy(&filesystem->base_path, &desc->pathname, sizeof(co_pathname_t));

	rc = co_os_fs_dir_join_unix_path(&filesystem->base_path, pathname);

	return rc;
}

static co_rc_t fs_stat(co_filesystem_t *filesystem, struct fuse_statfs_out *statfs)
{
	return filesystem->ops->fs_stat(filesystem, statfs);	
}

void co_monitor_file_system(co_monitor_t *cmon, unsigned int unit,
			    enum fuse_opcode opcode, unsigned long *params)
{
	int ino = -1;
	co_filesystem_t *filesystem;
	co_inode_t *inode;
	int result = 0;

	filesystem = cmon->filesystems[unit];
	if (!filesystem) {
		result = -ENODEV;
		goto out;
	}

	switch (opcode) {
	case FUSE_MOUNT:
		result = fs_mount(filesystem, (char*)(&co_passage_page->params[30]),
				  co_passage_page->params[5],
				  co_passage_page->params[6],
				  co_passage_page->params[7],
				  co_passage_page->params[8]);
		result = translate_code(result);
		goto out;
	case FUSE_STATFS:
		result = fs_stat(filesystem, (struct fuse_statfs_out *)(&co_passage_page->params[5]));
		result = translate_code(result);
		goto out;
	default:
		break;
	}

	ino = params[0];
	inode = ino_num_to_inode(ino, filesystem);

	switch (opcode) {
	case FUSE_SETATTR: {
		result = inode_set_attr(filesystem, inode, 
					co_passage_page->params[5],
					(struct fuse_attr *)(&co_passage_page->params[6]));
		result = translate_code(result);
		break;
	}

	case FUSE_RENAME: {
		char *str = (char *)&co_passage_page->params[30];
		result = inode_rename(filesystem, inode, 
				      co_passage_page->params[5],
				      str,
				      str + co_strlen(str) + 1);
		result = translate_code(result);
		break;
	}

	case FUSE_FORGET: {
		inode_forget(filesystem, inode);
		break;
	}

	case FUSE_MKNOD:
		result = inode_mknod(filesystem, inode, 
				     co_passage_page->params[5],
				     co_passage_page->params[6],
				     (char *)&co_passage_page->params[30],
				     (int *)&co_passage_page->params[7],
				     (struct fuse_attr *)(&co_passage_page->params[8]));
		result = translate_code(result);
		break;

	case FUSE_MKDIR:
		result = inode_mkdir(filesystem, inode, 
				      co_passage_page->params[5],
				      (char *)&co_passage_page->params[30]);
		result = translate_code(result);
		break;

	case FUSE_UNLINK:
		result = inode_unlink(filesystem, inode, 
				      (char *)&co_passage_page->params[30]);
		result = translate_code(result);
		break;

	case FUSE_RMDIR: 
		result = inode_rmdir(filesystem, inode, 
				     (char *)&co_passage_page->params[30]);
		result = translate_code(result);
		break;

	case FUSE_WRITE: {
		result = inode_write(cmon, filesystem, inode, 
				     *((unsigned long long *)&co_passage_page->params[5]),
				     co_passage_page->params[7],
				     co_passage_page->params[8]);
		result = translate_code(result);
		break;
	}

	case FUSE_READ: {
		result = inode_read(cmon, filesystem, inode, 
				    *((unsigned long long *)&co_passage_page->params[5]),
				    co_passage_page->params[7],
				    co_passage_page->params[8]);
		result = translate_code(result);
		break;
	}

	case FUSE_OPEN: {
		result = inode_open(filesystem, inode, co_passage_page->params[5]);
		result = translate_code(result);
		break;
	}

	case FUSE_LOOKUP: {
		result = 
			inode_lookup(filesystem, inode,
				     (char *)&co_passage_page->params[30],
				     (struct fuse_lookup_out *)&co_passage_page->params[5]);
		result = translate_code(result);
		break;
	}
	case FUSE_GETATTR: {
		result = inode_get_attr(filesystem, inode,
					(struct fuse_getattr_out *)&co_passage_page->params[5]);
		result = translate_code(result);
		break;
	}

	case FUSE_DIR_OPEN:
		result = inode_dir_open(filesystem, inode);
		result = translate_code(result);
		break;

	case FUSE_DIR_READ:
		result = inode_dir_read(cmon, inode, 
					co_passage_page->params[6],
					co_passage_page->params[5], 
					&co_passage_page->params[7],
					co_passage_page->params[8]);
		result = translate_code(result);
		break;

	case FUSE_DIR_RELEASE:
		result = inode_dir_release(inode);
		result = translate_code(result);
		break;

	case FUSE_GETDIR:
		break;
	default:
		break;
	}	

out:
	co_passage_page->params[4] = result;
}

void co_monitor_unregister_filesystems(co_monitor_t *cmon)
{
	int i;

	for (i=0; i < CO_MODULE_MAX_COFS; i++)
		co_monitor_file_system_free(cmon, i);
}


/*
 *  Flat mode implementation.
 */

static co_rc_t flat_mode_inode_rename(co_filesystem_t *filesystem, co_inode_t *old_inode, co_inode_t *new_inode, 
			     char *oldname, char *newname)
{
	char *old_dirname = NULL, *new_dirname = NULL;
	co_rc_t rc;

	rc = co_os_fs_dir_inode_to_path(filesystem, old_inode, &old_dirname, oldname);
	if (CO_OK(rc)) {
		rc = co_os_fs_dir_inode_to_path(filesystem, new_inode, &new_dirname, newname);
		if (CO_OK(rc)) {
			rc = co_os_file_rename(old_dirname, new_dirname);
			co_os_free(new_dirname);
		}
		co_os_free(old_dirname);
	}

	return rc;
}

static co_rc_t flat_mode_getattr(co_filesystem_t *fs, co_inode_t *dir,
				 char *name, struct fuse_attr *attr)
{
	char *filename;
	co_rc_t rc;

	rc = co_os_fs_dir_inode_to_path(fs, dir, &filename, name);
	if (!CO_OK(rc))
		return rc;

	rc = co_os_fs_get_attr(fs, filename, attr);
	co_os_free(filename);

	return rc;
}

static co_rc_t flat_mode_getdir(co_filesystem_t *fs, co_inode_t *dir, co_filesystem_dir_names_t *names)
{
	char *dirname;
	co_rc_t rc;

	rc = co_os_fs_inode_to_path(fs, dir, &dirname, 1);
	if (!CO_OK(rc))
		return rc;

	rc = co_os_file_getdir(dirname, names);
	co_os_free(dirname);

	return rc;
}

static co_rc_t flat_mode_inode_read_write(co_monitor_t *linuxvm, co_filesystem_t *filesystem, co_inode_t *inode, 
				  unsigned long long offset, unsigned long size,
				  vm_ptr_t src_buffer, bool_t read)
{
	char *filename;
	co_rc_t rc;

	rc = co_os_fs_inode_to_path(filesystem, inode, &filename, 0);
	if (!CO_OK(rc))
		return rc;
	
	rc = co_os_file_read_write(linuxvm, filename, offset, size, src_buffer, read);
	co_os_free(filename);

	return rc;
}

static co_rc_t flat_mode_inode_mknod(co_filesystem_t *filesystem, co_inode_t *inode, unsigned long mode, 
			     unsigned long rdev, char *name, int *ino, struct fuse_attr *attr)
{
	char *filename;
	co_rc_t rc;

	rc = co_os_fs_dir_inode_to_path(filesystem, inode, &filename, name);
	if (!CO_OK(rc))
		return rc;

	rc = co_os_file_mknod(filename);
	co_os_free(filename);

	return rc;
}

static co_rc_t flat_mode_inode_set_attr(co_filesystem_t *filesystem, co_inode_t *inode,
				unsigned long valid, struct fuse_attr *attr)
{
	char *filename;
	co_rc_t rc;

	rc = co_os_fs_inode_to_path(filesystem, inode, &filename, 0);
	if (!CO_OK(rc))
		return rc;

	rc = co_os_file_set_attr(filename, valid, attr);
	co_os_free(filename);

	return rc;
} 

static co_rc_t flat_mode_inode_mkdir(co_filesystem_t *filesystem, co_inode_t *inode, unsigned long mode, 
			     char *name)
{
	char *dirname;
	co_rc_t rc;

	rc = co_os_fs_dir_inode_to_path(filesystem, inode, &dirname, name);
	if (!CO_OK(rc))
		return rc;

	rc = co_os_file_mkdir(dirname);
	co_os_free(dirname);

	return rc;
}

static co_rc_t flat_mode_inode_unlink(co_filesystem_t *filesystem, co_inode_t *inode, char *name)
{
	char *filename;
	co_rc_t rc;

	rc = co_os_fs_dir_inode_to_path(filesystem, inode, &filename, name);
	if (!CO_OK(rc))
		return rc;

	rc = co_os_file_unlink(filename);
	co_os_free(filename);

	return rc;
}

static co_rc_t flat_mode_inode_rmdir(co_filesystem_t *filesystem, co_inode_t *inode, char *name)
{
	char *dirname;
	co_rc_t rc;

	rc = co_os_fs_dir_inode_to_path(filesystem, inode, &dirname, name);
	if (!CO_OK(rc))
		return rc;

	rc = co_os_file_rmdir(dirname);
	co_os_free(dirname);

	return rc;
}


static co_rc_t flat_mode_fs_stat(co_filesystem_t *filesystem, struct fuse_statfs_out *statfs)
{
	return co_os_file_fs_stat(filesystem, statfs);
}

static struct co_filesystem_ops flat_mode = {
	.inode_rename = flat_mode_inode_rename,
	.getattr = flat_mode_getattr,
	.getdir = flat_mode_getdir,
	.inode_read_write = flat_mode_inode_read_write,
	.inode_mknod = flat_mode_inode_mknod,
	.inode_set_attr = flat_mode_inode_set_attr,
	.inode_mkdir = flat_mode_inode_mkdir,
	.inode_unlink = flat_mode_inode_unlink,
	.inode_rmdir = flat_mode_inode_rmdir,
	.fs_stat = flat_mode_fs_stat,
};