isofs.c

newos is new operation system

}

//--------------------------------------------------------------------------------
static int isofs_fsync(fs_cookie _fs, fs_vnode _v)
{
	struct isofs_vnode *v = (struct isofs_vnode *)_v;

	TOUCH(v);

	TRACE(("isofs_fsync: entry on vnode 0x%x\n", v->id));
	return 0;
}

//--------------------------------------------------------------------------------
static int isofs_opendir(fs_cookie _fs, fs_vnode _v, dir_cookie *_cookie)
{
	struct isofs *fs = (struct isofs *)_fs;
	struct isofs_vnode *v = (struct isofs_vnode *)_v;
	struct isofs_cookie *cookie;
	int err = 0;

	TRACE(("isofs_opendir: vnode 0x%x\n", v));

	if(v->stream.type != STREAM_TYPE_DIR)
		return ERR_VFS_NOT_DIR;

	cookie = kmalloc(sizeof(struct isofs_cookie));
	if(cookie == NULL)
		return ERR_NO_MEMORY;

	mutex_lock(&fs->lock);

	iso_scan_dir(fs, v);
	cookie->u.dir.ptr = v->stream.dir_head;

	*_cookie = cookie;

	mutex_unlock(&fs->lock);
	return err;
}

//--------------------------------------------------------------------------------
static int isofs_closedir(fs_cookie _fs, fs_vnode _v, dir_cookie _cookie)
{
	struct isofs *fs = _fs;
	struct isofs_vnode *v = _v;
	struct isofs_cookie *cookie = _cookie;

	TOUCH(fs);TOUCH(v);TOUCH(cookie);

	TRACE(("isofs_closedir: entry vnode 0x%x, cookie 0x%x\n", v, cookie));

	if(v->stream.type != STREAM_TYPE_DIR)
		return ERR_VFS_NOT_DIR;

	if(cookie) {
		kfree(cookie);
	}

	return 0;
}

//--------------------------------------------------------------------------------
static int isofs_rewinddir(fs_cookie _fs, fs_vnode _v, dir_cookie _cookie)
{
	struct isofs_vnode *v = _v;
	struct isofs_cookie *cookie = _cookie;
	int err = 0;

	TOUCH(v);

	TRACE(("isofs_rewinddir: vnode 0x%x, cookie 0x%x\n", v, cookie));

	if(v->stream.type != STREAM_TYPE_DIR)
		return ERR_VFS_NOT_DIR;

	cookie->u.dir.ptr = cookie->s->dir_head;

	return err;
}

//--------------------------------------------------------------------------------
static int isofs_readdir(fs_cookie _fs, fs_vnode _v, dir_cookie _cookie, void *buf, size_t len)
{
	struct isofs *fs = _fs;
	struct isofs_vnode *v = _v;
	struct isofs_cookie *cookie = _cookie;
	int err = 0;

	TOUCH(v);

	TRACE(("isofs_readdir: vnode 0x%x, cookie 0x%x, len 0x%x\n", v, cookie, len));

	if(v->stream.type != STREAM_TYPE_DIR)
		return ERR_VFS_NOT_DIR;

	if(cookie->u.dir.ptr == NULL)
		return 0;

	mutex_lock(&fs->lock);

	if(strlen(cookie->u.dir.ptr->name) + 1 > len) {
		err = ERR_VFS_INSUFFICIENT_BUF;
		goto err;
	}

	err = user_strcpy(buf, cookie->u.dir.ptr->name);
	if(err < 0)
		goto err;

	err = strlen(cookie->u.dir.ptr->name) + 1;

	cookie->u.dir.ptr = cookie->u.dir.ptr->dir_next;

err:
	mutex_unlock(&fs->lock);

	return err;
}

//--------------------------------------------------------------------------------
static int isofs_open(fs_cookie _fs, fs_vnode _v, file_cookie *_cookie, int oflags)
{
	struct isofs_vnode *v = _v;
	struct isofs_cookie *cookie;
	int err = 0;

	TRACE(("isofs_open: vnode 0x%x, oflags 0x%x\n", v, oflags));

	if(v->stream.type == STREAM_TYPE_DIR)
		return ERR_VFS_IS_DIR;

	// Allocate our cookie for storage of position
	cookie = kmalloc(sizeof(struct isofs_cookie));
	if(cookie == NULL) {
		err = ERR_NO_MEMORY;
		goto err;
	}

	// Setup our cookie to start of stream data
	cookie->s = &v->stream;
	cookie->u.file.pos = 0;

	// Give cookie to caller
	*_cookie = cookie;
err:
	return err;
}

//--------------------------------------------------------------------------------
static int isofs_close(fs_cookie _fs, fs_vnode _v, file_cookie _cookie)
{
	struct isofs_vnode *v = _v;
	struct isofs_cookie *cookie = _cookie;

	TOUCH(v); TOUCH(cookie);

	TRACE(("isofs_close: entry vnode 0x%x, cookie 0x%x\n", v, cookie));

	if(v->stream.type == STREAM_TYPE_DIR)
		return ERR_VFS_IS_DIR;

	return 0;
}

//--------------------------------------------------------------------------------
static int isofs_freecookie(fs_cookie _fs, fs_vnode _v, file_cookie _cookie)
{
	struct isofs_vnode *v = _v;
	struct isofs_cookie *cookie = _cookie;

	TOUCH(v); TOUCH(cookie);

	TRACE(("isofs_freecookie: entry vnode 0x%x, cookie 0x%x\n", v, cookie));

	if(v->stream.type == STREAM_TYPE_DIR)
		return ERR_VFS_IS_DIR;

	if (cookie)
		kfree(cookie);

	return 0;
}

//--------------------------------------------------------------------------------
#define READ_CHUNK 16384
static ssize_t isofs_read(fs_cookie _fs, fs_vnode _v, file_cookie _cookie,
							void *buf, off_t pos, ssize_t len)
{
	struct isofs *fs = _fs;
	struct isofs_vnode *v = _v;
	struct isofs_cookie *cookie = _cookie;
	ssize_t err = 0;
	ssize_t totread = 0;
	char   *tempbuf = 0;

	TOUCH(v);

	TRACE(("isofs_read: vnode 0x%x, cookie 0x%x, pos 0x%x 0x%x, len 0x%x\n", v, cookie, pos, len));

	if(v->stream.type == STREAM_TYPE_DIR)
		return ERR_VFS_IS_DIR;

	// If size is negative, forget it
	if(len <= 0)
		return 0;

	mutex_lock(&fs->lock);

	// If position is negative, we'll read from current pos
	if (pos < 0) {
		// we'll read where the cookie is at
		pos = cookie->u.file.pos;
	}


	// If position is past filelength, forget it
	if (pos >= cookie->s->data_len) {
		err = 0;
		goto error;
	}

	// If read goes partially beyond EOF
	if (pos + len > cookie->s->data_len) {
		// trim the read
		len = cookie->s->data_len - pos;
	}

	tempbuf= kmalloc(READ_CHUNK);
	if(!tempbuf) {
		goto error;
	}

	while (len) {
		ssize_t to_read= (READ_CHUNK< len) ? READ_CHUNK : len;
		err = sys_read(fs->fd, tempbuf, cookie->s->data_pos + pos, to_read);
		if(err <= 0) {
			goto error;
		}
		user_memcpy(buf, tempbuf, err);
		pos += err;
		len -= err;
		buf = ((char*)buf)+err;
		totread += err;

		// Move to next bit of the file
	}
	kfree(tempbuf);
	tempbuf = 0;
	err = totread;
	cookie->u.file.pos = pos;

error:
	mutex_unlock(&fs->lock);
	if(tempbuf)
		kfree(tempbuf);

	return err;
}

//--------------------------------------------------------------------------------
static ssize_t isofs_write(fs_cookie fs, fs_vnode _v, file_cookie cookie, const void *buf, off_t pos, ssize_t len)
{
	struct isofs_vnode *v = _v;

	TRACE(("isofs_write: vnode 0x%x, cookie 0x%x, pos 0x%x 0x%x, len 0x%x\n", v, cookie, pos, len));

	if(v->stream.type == STREAM_TYPE_DIR)
		return ERR_VFS_IS_DIR;

	return ERR_VFS_READONLY_FS;
}

//--------------------------------------------------------------------------------
static int isofs_seek(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, off_t pos, seek_type st)
{
	struct isofs *fs = _fs;
	struct isofs_vnode *v = _v;
	struct isofs_cookie *cookie = _cookie;
	int err = 0;

	TOUCH(v);

	TRACE(("isofs_seek: vnode 0x%x, cookie 0x%x, pos 0x%x 0x%x, seek_type %d\n", v, cookie, pos, st));

	if(v->stream.type == STREAM_TYPE_DIR)
		return ERR_VFS_IS_DIR;

	mutex_lock(&fs->lock);

	switch(st) {
		case _SEEK_SET:
			if(pos < 0)
				pos = 0;
			if(pos > cookie->s->data_len)
				pos = cookie->s->data_len;
			cookie->u.file.pos = pos;
			break;
		case _SEEK_CUR:
			if(pos + cookie->u.file.pos > cookie->s->data_len)
				cookie->u.file.pos = cookie->s->data_len;
			else if(pos + cookie->u.file.pos < 0)
				cookie->u.file.pos = 0;
			else
				cookie->u.file.pos += pos;
			break;
		case _SEEK_END:
			if(pos > 0)
				cookie->u.file.pos = cookie->s->data_len;
			else if(pos + cookie->s->data_len < 0)
				cookie->u.file.pos = 0;
			else
				cookie->u.file.pos = pos + cookie->s->data_len;
			break;
		default:
			err = ERR_INVALID_ARGS;

	}

	mutex_unlock(&fs->lock);

	return err;
}

//--------------------------------------------------------------------------------
static int isofs_ioctl(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, int op, void *buf, size_t len)
{
	TRACE(("isofs_ioctl: vnode 0x%x, cookie 0x%x, op %d, buf 0x%x, len 0x%x\n", _v, _cookie, op, buf, len));

	return ERR_INVALID_ARGS;
}

//--------------------------------------------------------------------------------
static int isofs_canpage(fs_cookie _fs, fs_vnode _v)
{
	struct isofs_vnode *v = _v;

	TOUCH(v);

	TRACE(("isofs_canpage: vnode 0x%x\n", v));

	return 0;
}

//--------------------------------------------------------------------------------
static ssize_t isofs_readpage(fs_cookie _fs, fs_vnode _v, iovecs *vecs, off_t pos)
{
	struct isofs_vnode *v = _v;

	TOUCH(v);

	TRACE(("isofs_readpage: vnode 0x%x, vecs 0x%x, pos 0x%x 0x%x\n", v, vecs, pos));

	return ERR_NOT_ALLOWED;
}

//--------------------------------------------------------------------------------
static int isofs_create(fs_cookie _fs, fs_vnode _dir, const char *name, void *create_args, vnode_id *new_vnid)
{
	return ERR_VFS_READONLY_FS;
}

//--------------------------------------------------------------------------------
static int isofs_unlink(fs_cookie _fs, fs_vnode _dir, const char *name)
{
	return ERR_VFS_READONLY_FS;
}

//--------------------------------------------------------------------------------
static int isofs_rename(fs_cookie _fs, fs_vnode _olddir, const char *oldname, fs_vnode _newdir, const char *newname)
{
	return ERR_VFS_READONLY_FS;
}

//--------------------------------------------------------------------------------
static int isofs_mkdir(fs_cookie _fs, fs_vnode _base_dir, const char *name)
{
	return ERR_VFS_READONLY_FS;
}

//--------------------------------------------------------------------------------
static int isofs_rmdir(fs_cookie _fs, fs_vnode _base_dir, const char *name)
{
	return ERR_VFS_READONLY_FS;
}

//--------------------------------------------------------------------------------
static ssize_t isofs_writepage(fs_cookie _fs, fs_vnode _v, iovecs *vecs, off_t pos)
{
	struct isofs_vnode *v = _v;

	TOUCH(v);

	TRACE(("isofs_writepage: vnode 0x%x, vecs 0x%x, pos 0x%x 0x%x\n", v, vecs, pos));

	return ERR_NOT_ALLOWED;
}

//--------------------------------------------------------------------------------
static int isofs_rstat(fs_cookie _fs, fs_vnode _v, struct file_stat *stat)
{
	struct isofs *fs = _fs;
	struct isofs_vnode *v = _v;
	int err = 0;

	TRACE(("isofs_rstat: vnode 0x%x (0x%x 0x%x), stat 0x%x\n", v, v->id, stat));

	mutex_lock(&fs->lock);

	stat->vnid = v->id;
	stat->type = v->stream.type;

	switch(v->stream.type) {
		case STREAM_TYPE_DIR:
			stat->size = 0;
			break;
		case STREAM_TYPE_FILE:
			stat->size = v->stream.data_len;
			break;
		default:
			err = ERR_INVALID_ARGS;
			break;
	}

	mutex_unlock(&fs->lock);

	return err;
}

//--------------------------------------------------------------------------------
static int isofs_wstat(fs_cookie _fs, fs_vnode _v, struct file_stat *stat, int stat_mask)
{
	return ERR_VFS_READONLY_FS;
}

//================================================================================
// REGISTRATION HANDLING
//================================================================================

static struct fs_calls isofs_calls = {
	&isofs_mount,		// mount
	&isofs_unmount,		// unmount
	&isofs_sync,		// sync

	isofs_lookup,		// lookup

	&isofs_getvnode,	// getvnode
	&isofs_putvnode,	// putvnode
	&isofs_removevnode,	// removevnode

	&isofs_opendir,		// opendir
	&isofs_closedir,	// closedir
	&isofs_rewinddir,	// rewinddir
	&isofs_readdir,		// readdir

	&isofs_open,		// open
	&isofs_close,		// close
	&isofs_freecookie,	// freecookie
	&isofs_fsync,		// fsync

	&isofs_read,		// read
	&isofs_write,		// write
	&isofs_seek,		// seek
	&isofs_ioctl,		// ioctl

	&isofs_canpage,		// canpage
	&isofs_readpage,	// readpage
	&isofs_writepage,	// writepage

	&isofs_create,		// create
	&isofs_unlink,		// unlink
	&isofs_rename,		// rename

	&isofs_mkdir,		// mkdir
	&isofs_rmdir,		// rmdir

	&isofs_rstat,		// rstat
	&isofs_wstat		// wstat
};

int fs_bootstrap(void);

//--------------------------------------------------------------------------------
int fs_bootstrap(void)
{
	dprintf("bootstrap_isofs: entry\n");
	return vfs_register_filesystem("isofs", &isofs_calls);
}