1 files changed, 124 insertions, 47 deletions

diff --git a/kernel/features/fs.c b/kernel/features/fs.c
index 14e6a9c..b59eb03 100644
--- a/kernel/features/fs.c
+++ b/kernel/features/fs.c
@@ -24,7 +24,7 @@ char *vfs_normalize_path(const char *path)
 	return fixed;
 }
 
-u32 vfs_mounted(struct device *dev, const char *path)
+u8 vfs_mounted(struct device *dev, const char *path)
 {
 	struct node *iterator = mount_points->head;
 	while (iterator) {
@@ -70,6 +70,8 @@ struct device *vfs_find_dev(const char *path)
 {
 	assert(path[0] == '/');
 	struct mount_info *m = vfs_find_mount_info(path);
+	if (m->dev->vfs->type == VFS_DEVFS) // TODO: ?
+		return device_get_by_name(path + strlen(m->path) + 1);
 	return m && m->dev ? m->dev : NULL;
 }
 
@@ -100,11 +102,11 @@ void vfs_list_mounts()
 	}
 }
 
-u32 vfs_mount(struct device *dev, const char *path)
+s32 vfs_mount(struct device *dev, const char *path)
 {
 	// TODO: Check if already mounted
 	if (!dev || !dev->id || vfs_mounted(dev, path))
-		return 0;
+		return -1;
 
 	char *fixed = vfs_normalize_path(path);
 
@@ -113,14 +115,20 @@ u32 vfs_mount(struct device *dev, const char *path)
 	m->dev = dev;
 	list_add(mount_points, m);
 
-	return 1;
+	return 0;
 }
 
-u32 vfs_read(const char *path, void *buf, u32 offset, u32 count)
+s32 vfs_read(const char *path, void *buf, u32 offset, u32 count)
 {
-	if (count == 0 || offset > count)
+	if (!count)
 		return 0;
 
+	if (offset > count)
+		return -1;
+
+	while (*path == ' ')
+		path++;
+
 	struct mount_info *m = vfs_find_mount_info(path);
 	assert(m && m->dev && m->dev->vfs && m->dev->vfs->read);
 
@@ -128,22 +136,58 @@ u32 vfs_read(const char *path, void *buf, u32 offset, u32 count)
 	if (len > 1)
 		path += len;
 
-	struct device *dev = m->dev;
-	return dev->vfs->read(path, buf, offset, count, dev);
+	return m->dev->vfs->read(path, buf, offset, count, m->dev);
+}
+
+s32 vfs_write(const char *path, void *buf, u32 offset, u32 count)
+{
+	if (!count)
+		return 0;
+
+	if (offset > count)
+		return -1;
+
+	while (*path == ' ')
+		path++;
+
+	struct mount_info *m = vfs_find_mount_info(path);
+	assert(m && m->dev && m->dev->vfs && m->dev->vfs->write);
+
+	u32 len = strlen(m->path);
+	if (len > 1)
+		path += len;
+
+	return m->dev->vfs->write(path, buf, offset, count, m->dev);
 }
 
-u32 vfs_write(const char *path, void *buf, u32 offset, u32 count)
+s32 vfs_stat(const char *path, struct stat *buf)
 {
-	struct device *dev = vfs_find_dev(path);
-	assert(dev && dev->vfs && dev->vfs->write);
-	return dev->vfs->write(path, buf, offset, count, dev);
+	while (*path == ' ')
+		path++;
+
+	struct mount_info *m = vfs_find_mount_info(path);
+	assert(m && m->dev && m->dev->vfs && m->dev->vfs->stat);
+
+	u32 len = strlen(m->path);
+	if (len > 1)
+		path += len;
+
+	return m->dev->vfs->stat(path, buf, m->dev);
 }
 
-u32 vfs_stat(const char *path, struct stat *buf)
+u8 vfs_ready(const char *path)
 {
-	struct device *dev = vfs_find_dev(path);
-	assert(dev && dev->vfs && dev->vfs->stat);
-	return dev->vfs->stat(path, buf, dev);
+	while (*path == ' ')
+		path++;
+
+	struct mount_info *m = vfs_find_mount_info(path);
+	assert(m && m->dev && m->dev->vfs && m->dev->vfs->ready);
+
+	u32 len = strlen(m->path);
+	if (len > 1)
+		path += len;
+
+	return m->dev->vfs->ready(path, m->dev);
 }
 
 void vfs_install(void)
@@ -163,7 +207,7 @@ void device_add(struct device *dev)
 	list_add(devices, dev);
 }
 
-struct device *device_get(u32 id)
+struct device *device_get_by_id(u32 id)
 {
 	struct node *iterator = devices->head;
 	while (iterator) {
@@ -174,25 +218,46 @@ struct device *device_get(u32 id)
 	return NULL;
 }
 
-u32 devfs_read(const char *path, void *buf, u32 offset, u32 count, struct device *dev)
+struct device *device_get_by_name(const char *name)
+{
+	struct node *iterator = devices->head;
+	while (iterator) {
+		if (!strcmp(((struct device *)iterator->data)->name, name))
+			return iterator->data;
+		iterator = iterator->next;
+	}
+	return NULL;
+}
+
+s32 devfs_read(const char *path, void *buf, u32 offset, u32 count, struct device *dev)
+{
+	struct device *target = device_get_by_name(path + 1);
+	if (!target || !target->read)
+		return 0;
+	return target->read(buf, offset, count, dev);
+}
+
+u8 devfs_ready(const char *path, struct device *dev)
 {
-	assert(dev && dev->read);
-	printf("%s - off: %d, cnt: %d, buf: %x, dev %x\n", path, offset, count, buf, dev);
-	return dev->read(buf, offset, count, dev);
+	(void)dev;
+
+	struct device *target = device_get_by_name(path + 1);
+	if (!target || !target->ready)
+		return 0;
+	return target->ready();
 }
 
 void device_install(void)
 {
 	devices = list_new();
 
-	struct vfs *vfs;
-	struct device *dev;
-
-	vfs = malloc(sizeof(*vfs));
+	struct vfs *vfs = malloc(sizeof(*vfs));
 	vfs->type = VFS_DEVFS;
 	vfs->read = devfs_read;
-	dev = malloc(sizeof(*dev));
+	vfs->ready = devfs_ready;
+	struct device *dev = malloc(sizeof(*dev));
 	dev->name = "dev";
+	dev->type = DEV_CHAR;
 	dev->vfs = vfs;
 	device_add(dev);
 	vfs_mount(dev, "/dev/");
@@ -204,6 +269,7 @@ void device_install(void)
  * EXT2
  */
 
+// TODO: Remove malloc from buffer_read (attempt in #56cd63f199)
 void *buffer_read(u32 block, struct device *dev)
 {
 	void *buf = malloc(BLOCK_SIZE);
@@ -215,8 +281,7 @@ struct ext2_superblock *get_superblock(struct device *dev)
 {
 	struct ext2_superblock *sb = buffer_read(EXT2_SUPER, dev);
 
-	if (sb->magic != EXT2_MAGIC)
-		return NULL;
+	assert(sb->magic == EXT2_MAGIC);
 	return sb;
 }
 
@@ -237,31 +302,38 @@ struct ext2_inode *get_inode(u32 i, struct device *dev)
 	u32 block = (index * EXT2_INODE_SIZE) / BLOCK_SIZE;
 	b += block_group;
 
-	u32 *data = buffer_read(b->inode_table + block, dev);
+	u32 *buf = buffer_read(b->inode_table + block, dev);
 	struct ext2_inode *in =
-		(struct ext2_inode *)((u32)data +
+		(struct ext2_inode *)((u32)buf +
 				      (index % (BLOCK_SIZE / EXT2_INODE_SIZE)) * EXT2_INODE_SIZE);
+
+	free(buf);
+	free(s);
+	free(b - block_group);
+
 	return in;
 }
 
 u32 read_indirect(u32 indirect, u32 block_num, struct device *dev)
 {
 	char *data = buffer_read(indirect, dev);
-	return *(u32 *)((u32)data + block_num * sizeof(u32));
+	u32 ind = *(u32 *)((u32)data + block_num * sizeof(u32));
+	free(data);
+	return ind;
 }
 
-u32 read_inode(struct ext2_inode *in, void *buf, u32 offset, u32 count, struct device *dev)
+s32 read_inode(struct ext2_inode *in, void *buf, u32 offset, u32 count, struct device *dev)
 {
 	// TODO: Support read offset
 	(void)offset;
 
 	if (!in || !buf)
-		return 0;
+		return -1;
 
 	u32 num_blocks = in->blocks / (BLOCK_SIZE / SECTOR_SIZE);
 
 	if (!num_blocks)
-		return 0;
+		return -1;
 
 	// TODO: memcpy block chunks until count is copied
 	while (BLOCK_SIZE * num_blocks > count)
@@ -269,28 +341,25 @@ u32 read_inode(struct ext2_inode *in, void *buf, u32 offset, u32 count, struct d
 
 	u32 indirect = 0;
 	u32 blocknum = 0;
-	char *data = 0;
 	// TODO: Support triply indirect pointers
 	// TODO: This can be heavily optimized by saving the indirect block lists
 	for (u32 i = 0; i < num_blocks; i++) {
 		if (i < 12) {
 			blocknum = in->block[i];
-			data = buffer_read(blocknum, dev);
-			memcpy((u32 *)((u32)buf + i * BLOCK_SIZE), data, BLOCK_SIZE);
 		} else if (i < BLOCK_COUNT + 12) {
 			indirect = in->block[12];
 			blocknum = read_indirect(indirect, i - 12, dev);
-			data = buffer_read(blocknum, dev);
-			memcpy((u32 *)((u32)buf + i * BLOCK_SIZE), data, BLOCK_SIZE);
 		} else {
 			indirect = in->block[13];
 			blocknum = read_indirect(indirect, (i - (BLOCK_COUNT + 12)) / BLOCK_COUNT,
 						 dev);
 			blocknum = read_indirect(blocknum, (i - (BLOCK_COUNT + 12)) % BLOCK_COUNT,
 						 dev);
-			data = buffer_read(blocknum, dev);
-			memcpy((u32 *)((u32)buf + i * BLOCK_SIZE), data, BLOCK_SIZE);
 		}
+
+		char *data = buffer_read(blocknum, dev);
+		memcpy((u32 *)((u32)buf + i * BLOCK_SIZE), data, BLOCK_SIZE);
+		free(data);
 		/* printf("Loaded %d of %d\n", i + 1, num_blocks); */
 	}
 
@@ -310,6 +379,7 @@ u32 find_inode(const char *name, u32 dir_inode, struct device *dev)
 	for (u32 q = 0; q < i->blocks / 2; q++) {
 		char *data = buffer_read(i->block[q], dev);
 		memcpy((u32 *)((u32)buf + q * BLOCK_SIZE), data, BLOCK_SIZE);
+		free(data);
 	}
 
 	struct ext2_dirent *d = (struct ext2_dirent *)buf;
@@ -341,7 +411,7 @@ struct ext2_inode *find_inode_by_path(const char *path, struct device *dev)
 	path_cp++;
 	u32 current_inode = EXT2_ROOT;
 
-	int i = 0;
+	u32 i = 0;
 	while (1) {
 		for (i = 0; path_cp[i] != '/' && path_cp[i] != '\0'; i++)
 			;
@@ -369,23 +439,23 @@ struct ext2_inode *find_inode_by_path(const char *path, struct device *dev)
 	return get_inode(inode, dev);
 }
 
-u32 ext2_read(const char *path, void *buf, u32 offset, u32 count, struct device *dev)
+s32 ext2_read(const char *path, void *buf, u32 offset, u32 count, struct device *dev)
 {
 	struct ext2_inode *in = find_inode_by_path(path, dev);
 	if (in)
 		return read_inode(in, buf, offset, count, dev);
 	else
-		return 0;
+		return -1;
 }
 
-u32 ext2_stat(const char *path, struct stat *buf, struct device *dev)
+s32 ext2_stat(const char *path, struct stat *buf, struct device *dev)
 {
 	if (!buf)
-		return 1;
+		return -1;
 
 	struct ext2_inode *in = find_inode_by_path(path, dev);
 	if (!in)
-		return 1;
+		return -1;
 
 	u32 num_blocks = in->blocks / (BLOCK_SIZE / SECTOR_SIZE);
 	u32 sz = BLOCK_SIZE * num_blocks;
@@ -395,3 +465,10 @@ u32 ext2_stat(const char *path, struct stat *buf, struct device *dev)
 
 	return 0;
 }
+
+u8 ext2_ready(const char *path, struct device *dev)
+{
+	(void)path;
+	(void)dev;
+	return 1;
+}