Kinda working VFS implementation

14 files changed, 163 insertions, 71 deletions

diff --git a/apps/cc.c b/apps/cc.c
index 6b571b1..305d82e 100644
--- a/apps/cc.c
+++ b/apps/cc.c
@@ -803,7 +803,7 @@ int main(int argc, char **argv)
 	}
 
 	void *file;
-	if (!(file = read(*argv))) {
+	if (!(file = sread(*argv))) {
 		printf("could not read file %s\n", *argv);
 		return -1;
 	}
diff --git a/apps/exec.c b/apps/exec.c
index e7cfcd8..100ce26 100644
--- a/apps/exec.c
+++ b/apps/exec.c
@@ -34,7 +34,8 @@ void on_submit(struct gui_event_keyboard *event, struct element *elem)
 	strcat(final, PATH);
 	strcat(final, inp);
 
-	if (stat(final)) {
+	struct stat s = { 0 };
+	if (stat(final, &s) && s.size) {
 		inp_elem->color_bg = COLOR_WHITE;
 		exec(final, inp, arg, NULL);
 	} else {
diff --git a/apps/files.c b/apps/files.c
index e21af5a..df590d9 100644
--- a/apps/files.c
+++ b/apps/files.c
@@ -38,7 +38,7 @@ void render_list(const char *path)
 		gui_remove_element(list);
 	list = gui_add_container(root, 0, 0, 100, 100, COLOR_BLACK);
 
-	struct dirent *d = read(path);
+	struct dirent *d = sread(path);
 
 	int sum = 0;
 	int calc = 0;
diff --git a/apps/server.c b/apps/server.c
index 3d3bb77..4840da3 100644
--- a/apps/server.c
+++ b/apps/server.c
@@ -33,11 +33,17 @@ int main()
 
 		memset(buf, 0, 4096);
 
-		u32 len = 0;
-		if ((len = stat(path)))
-			len = http_response(HTTP_200, len, read(path), buf);
+		struct stat s_file = { 0 };
+		int res_file = stat(path, &s_file);
+
+		struct stat s_error = { 0 };
+		stat(path, &s_error);
+
+		int len;
+		if (res_file && s_file.size)
+			len = http_response(HTTP_200, s_file.size, sread(path), buf);
 		else
-			len = http_response(HTTP_404, stat(ERROR), read(ERROR), buf);
+			len = http_response(HTTP_404, s_error.size, sread(ERROR), buf);
 
 		net_send(socket, buf, len);
 		net_close(socket);
diff --git a/kernel/features/fs.c b/kernel/features/fs.c
index 06a1d8c..a4a1ef6 100644
--- a/kernel/features/fs.c
+++ b/kernel/features/fs.c
@@ -26,7 +26,7 @@ char *vfs_normalize_path(const char *path)
 	return fixed;
 }
 
-struct device *vfs_find_dev(char *path)
+struct mount_info *vfs_recursive_find(char *path)
 {
 	struct node *iterator = mount_points->head;
 	char *fixed = vfs_normalize_path(path);
@@ -36,7 +36,7 @@ struct device *vfs_find_dev(char *path)
 		struct mount_info *m = iterator->data;
 		if (!strcmp(m->path, fixed)) {
 			free(fixed);
-			return m->dev;
+			return m;
 		}
 		iterator = iterator->next;
 	}
@@ -47,23 +47,20 @@ struct device *vfs_find_dev(char *path)
 	}
 
 	*(strrchr(fixed, '/') + 1) = '\0';
-	return vfs_find_dev(fixed);
+	return vfs_recursive_find(fixed);
 }
 
-u32 vfs_mount(struct device *dev, const char *path)
+struct mount_info *vfs_find_mount_info(const char *path)
 {
-	// TODO: Check if already mounted
-	if (!dev || !dev->id)
-		return 0;
-
-	char *fixed = vfs_normalize_path(path);
-
-	struct mount_info *m = malloc(sizeof(*m));
-	m->path = fixed;
-	m->dev = dev;
-	list_add(mount_points, m);
+	assert(path[0] == '/');
+	return vfs_recursive_find(strdup(path));
+}
 
-	return 1;
+struct device *vfs_find_dev(const char *path)
+{
+	assert(path[0] == '/');
+	struct mount_info *m = vfs_find_mount_info(path);
+	return m && m->dev ? m->dev : NULL;
 }
 
 const char *vfs_resolve_type(enum vfs_type type)
@@ -93,19 +90,50 @@ void vfs_list_mounts()
 	}
 }
 
-u32 vfs_read(char *path, void *buf, u32 offset, u32 count)
+u32 vfs_mount(struct device *dev, const char *path)
 {
-	struct device *dev = vfs_find_dev(path);
-	assert(dev && dev->vfs && dev->vfs->read);
+	// TODO: Check if already mounted
+	if (!dev || !dev->id)
+		return 0;
+
+	char *fixed = vfs_normalize_path(path);
+
+	struct mount_info *m = malloc(sizeof(*m));
+	m->path = fixed;
+	m->dev = dev;
+	list_add(mount_points, m);
+
+	return 1;
+}
+
+u32 vfs_read(const char *path, void *buf, u32 offset, u32 count)
+{
+	if (count == 0 || offset > count)
+		return 0;
+
+	struct mount_info *m = vfs_find_mount_info(path);
+	assert(m && m->dev && m->dev->vfs && m->dev->vfs->read);
+
+	u32 len = strlen(m->path);
+	if (len > 1)
+		path += len;
+
+	struct device *dev = m->dev;
 	return dev->vfs->read(path, buf, offset, count, dev);
 }
 
-u32 vfs_stat(char *path)
+u32 vfs_write(const char *path, void *buf, u32 offset, u32 count)
+{
+	struct device *dev = vfs_find_dev(path);
+	assert(dev && dev->vfs && dev->vfs->write);
+	return dev->vfs->write(path, buf, offset, count, dev);
+}
+
+u32 vfs_stat(const char *path, struct stat *buf)
 {
-	(void)path;
-	printf("NOT IMPLEMENTED!\n");
-	loop();
-	return 0;
+	struct device *dev = vfs_find_dev(path);
+	assert(dev && dev->vfs && dev->vfs->stat);
+	return dev->vfs->stat(path, buf, dev);
 }
 
 void vfs_install(void)
@@ -136,6 +164,11 @@ struct device *device_get(u32 id)
 	return NULL;
 }
 
+u32 devfs_read(const char *path, void *buf, u32 offset, u32 count, struct device *dev)
+{
+	return printf("%s - off: %d, cnt: %d, buf: %x, dev %x\n", path, offset, count, buf, dev);
+}
+
 void device_install(void)
 {
 	devices = list_new();
@@ -145,6 +178,7 @@ void device_install(void)
 
 	vfs = malloc(sizeof(*vfs));
 	vfs->type = VFS_DEVFS;
+	vfs->read = devfs_read;
 	dev = malloc(sizeof(*dev));
 	dev->name = "dev";
 	dev->vfs = vfs;
@@ -154,13 +188,14 @@ void device_install(void)
 	vfs = malloc(sizeof(*vfs));
 	vfs->type = VFS_EXT2;
 	vfs->read = ext2_read;
+	vfs->stat = ext2_stat;
 	dev = malloc(sizeof(*dev));
 	dev->name = "/dev/hda"; // TODO: Use actual disk device
 	dev->vfs = vfs;
 	device_add(dev);
 	vfs_mount(dev, "/");
 
-	vfs_list_mounts();
+	/* vfs_list_mounts(); */
 }
 
 /**
@@ -213,9 +248,7 @@ u32 read_indirect(u32 indirect, u32 block_num)
 u32 read_inode(struct ext2_inode *in, void *buf, u32 offset, u32 count, struct device *dev)
 {
 	// TODO: Support all read parameters
-	(void)buf;
 	(void)offset;
-	(void)count;
 	(void)dev;
 
 	assert(in);
@@ -224,15 +257,19 @@ u32 read_inode(struct ext2_inode *in, void *buf, u32 offset, u32 count, struct d
 
 	u32 num_blocks = in->blocks / (BLOCK_SIZE / SECTOR_SIZE);
 
-	assert(num_blocks != 0);
+	assert(num_blocks);
 	if (!num_blocks)
 		return 0;
 
+	// TODO: memcpy block chunks until count is copied
+	while (BLOCK_SIZE * num_blocks > count)
+		num_blocks--;
+
 	/* u32 sz = BLOCK_SIZE * num_blocks; */
 	/* u32 sz = in->size; */
 	/* void *buf = malloc(sz); */
 	/* printf("Loading %dKiB\n", sz >> 10); */
-	assert(buf != NULL);
+	assert(buf);
 
 	u32 indirect = 0;
 	u32 blocknum = 0;
@@ -295,40 +332,46 @@ u32 find_inode(const char *name, u32 dir_inode)
 	return (unsigned)-1;
 }
 
-struct ext2_inode *find_inode_by_path(char *path)
+struct ext2_inode *find_inode_by_path(const char *path)
 {
 	if (path[0] != '/')
 		return 0;
 
-	path++;
+	char *path_cp = strdup(path);
+	char *init = path_cp; // For freeing
+
+	path_cp++;
 	u32 current_inode = EXT2_ROOT;
 
 	int i = 0;
 	while (1) {
-		for (i = 0; path[i] != '/' && path[i] != '\0'; i++)
+		for (i = 0; path_cp[i] != '/' && path_cp[i] != '\0'; i++)
 			;
 
-		if (path[i] == '\0')
+		if (path_cp[i] == '\0')
 			break;
 
-		path[i] = '\0';
-		current_inode = find_inode(path, current_inode);
-		path[i] = '/';
+		path_cp[i] = '\0';
+		current_inode = find_inode(path_cp, current_inode);
+		path_cp[i] = '/';
 
-		if (current_inode == 0)
+		if (current_inode == 0) {
+			free(init);
 			return 0;
+		}
 
-		path += i + 1;
+		path_cp += i + 1;
 	}
 
-	u32 inode = find_inode(path, current_inode);
+	u32 inode = find_inode(path_cp, current_inode);
+	free(init);
 	if ((signed)inode <= 0)
 		return 0;
 
 	return get_inode(inode);
 }
 
-u32 ext2_read(char *path, void *buf, u32 offset, u32 count, struct device *dev)
+u32 ext2_read(const char *path, void *buf, u32 offset, u32 count, struct device *dev)
 {
 	struct ext2_inode *in = find_inode_by_path(path);
 	if (in)
@@ -337,11 +380,20 @@ u32 ext2_read(char *path, void *buf, u32 offset, u32 count, struct device *dev)
 		return 0;
 }
 
-u32 ext2_stat(char *path)
+u32 ext2_stat(const char *path, struct stat *buf, struct device *dev)
 {
+	if (!buf)
+		return 0;
+
 	struct ext2_inode *in = find_inode_by_path(path);
 	if (!in)
 		return 0;
 
-	return in->size;
+	u32 num_blocks = in->blocks / (BLOCK_SIZE / SECTOR_SIZE);
+	u32 sz = BLOCK_SIZE * num_blocks;
+
+	buf->dev_id = dev->id;
+	buf->size = sz; // Actually in->size but ext2..
+
+	return 1;
 }
diff --git a/kernel/features/load.c b/kernel/features/load.c
index e5b6903..1eb34d3 100644
--- a/kernel/features/load.c
+++ b/kernel/features/load.c
@@ -12,8 +12,10 @@
 int bin_load(char *path, struct proc *proc)
 {
 	// TODO: Remove hardcoded filesize
-	char *data = malloc(0xffff);
-	vfs_read(path, data, 0, 0xffff);
+	struct stat s = { 0 };
+	vfs_stat(path, &s);
+	char *data = malloc(s.size);
+	vfs_read(path, data, 0, s.size);
 
 	u32 stack = (u32)malloc(0x2000) + 0x1000;
 
diff --git a/kernel/features/syscall.c b/kernel/features/syscall.c
index 436db5a..e2df79a 100644
--- a/kernel/features/syscall.c
+++ b/kernel/features/syscall.c
@@ -34,17 +34,15 @@ void syscall_handler(struct regs *r)
 		break;
 	}
 	case SYS_STAT: {
-		r->eax = (u32)vfs_stat((char *)r->ebx);
+		r->eax = (u32)vfs_stat((char *)r->ebx, (struct stat *)r->ecx);
 		break;
 	}
 	case SYS_READ: {
-		printf("NOT IMPLEMENTED!\n");
-		loop();
-		//r->eax = (u32)vfs_read((char *)r->ebx);
+		r->eax = (u32)vfs_read((char *)r->ebx, (void *)r->ecx, r->edx, r->esi);
 		break;
 	}
 	case SYS_WRITE: {
-		// TODO: Write ext2 support
+		r->eax = (u32)vfs_write((char *)r->ebx, (void *)r->ecx, r->edx, r->esi);
 		break;
 	}
 	case SYS_EXEC: {
diff --git a/kernel/inc/fs.h b/kernel/inc/fs.h
index 7831603..06154e7 100644
--- a/kernel/inc/fs.h
+++ b/kernel/inc/fs.h
@@ -4,6 +4,7 @@
 #define FS_H
 
 #include <def.h>
+#include <sys.h>
 
 /**
  * Device
@@ -29,8 +30,9 @@ enum vfs_type { VFS_DEVFS, VFS_TMPFS, VFS_PROCFS, VFS_EXT2 };
 struct vfs {
 	enum vfs_type type;
 	int flags;
-	u32 (*read)(char *path, void *buf, u32 offset, u32 count, struct device *dev);
-	u32 (*write)(char *path, void *buf, u32 offset, u32 count, struct device *dev);
+	u32 (*read)(const char *path, void *buf, u32 offset, u32 count, struct device *dev);
+	u32 (*write)(const char *path, void *buf, u32 offset, u32 count, struct device *dev);
+	u32 (*stat)(const char *path, struct stat *buf, struct device *dev);
 };
 
 struct mount_info {
@@ -40,8 +42,9 @@ struct mount_info {
 
 void vfs_install(void);
 
-u32 vfs_read(char *path, void *buf, u32 offset, u32 count);
-u32 vfs_stat(char *path);
+u32 vfs_read(const char *path, void *buf, u32 offset, u32 count);
+u32 vfs_write(const char *path, void *buf, u32 offset, u32 count);
+u32 vfs_stat(const char *path, struct stat *buf);
 
 /**
  * EXT2
@@ -134,7 +137,7 @@ struct ext2_file {
 	u32 curr_block_pos;
 };
 
-u32 ext2_read(char *path, void *buf, u32 offset, u32 count, struct device *dev);
-u32 ext2_stat(char *path);
+u32 ext2_read(const char *path, void *buf, u32 offset, u32 count, struct device *dev);
+u32 ext2_stat(const char *path, struct stat *buf, struct device *dev);
 
 #endif
diff --git a/libc/inc/sys.h b/libc/inc/sys.h
index 64ce7f5..4a1d1e0 100644
--- a/libc/inc/sys.h
+++ b/libc/inc/sys.h
@@ -4,6 +4,8 @@
 #ifndef SYS_H
 #define SYS_H
 
+#include <def.h>
+
 #define KEYBOARD_MAGIC 0x555555
 #define MOUSE_MAGIC 0xaaaaaa
 
@@ -15,7 +17,7 @@ enum sys {
 	SYS_READ, // Read file
 	SYS_WRITE, // Write to file
 	SYS_EXEC, // Execute path
-	SYS_EXIT, // Exit current process
+	SYS_EXIT, // Exit current process // TODO: Free all memory of process
 	SYS_YIELD, // Switch to next process
 	SYS_TIME, // Get kernel time
 	SYS_REGISTER, // Register for event
@@ -53,6 +55,14 @@ struct event_mouse {
 	int but3;
 };
 
+struct stat {
+	u32 dev_id;
+	u32 mode;
+	u32 uid;
+	u32 gid;
+	u32 size;
+};
+
 #if defined(userspace)
 
 int sys0(enum sys num);
@@ -68,9 +78,11 @@ int sysv(enum sys num, ...);
  */
 
 #define loop() sys0(SYS_LOOP)
-#define stat(path) (u32) sys1(SYS_STAT, (int)(path))
-#define read(path) (void *)sys1(SYS_READ, (int)(path))
-#define write(path, buf) sys2(SYS_WRITE, (int)(path), (buf))
+#define stat(path, stat) (u32) sys2(SYS_STAT, (int)(path), (int)(stat))
+#define read(path, buf, offset, count)                                                             \
+	(u32) sys4(SYS_READ, (int)(path), (int)(buf), (int)(offset), (int)(count))
+#define write(path, buf, offset, count)                                                            \
+	(u32) sys4(SYS_WRITE, (int)(path), (int)(buf), (int)(offset), (int)(count))
 #define exec(path, ...) (int)sysv(SYS_EXEC, (int)(path), ##__VA_ARGS__)
 #define exit(status)                                                                               \
 	{                                                                                          \
@@ -96,5 +108,17 @@ static inline struct message *msg_receive_loop()
 	return msg;
 }
 
+// Simple read wrapper
+#include <mem.h>
+static inline void *sread(const char *path)
+{
+	struct stat s = { 0 };
+	if (!stat(path, &s) || !s.size)
+		return NULL;
+	void *buf = malloc(s.size);
+	read(path, buf, 0, s.size);
+	return buf;
+}
+
 #endif
 #endif
diff --git a/libgui/bmp.c b/libgui/bmp.c
index 3097e99..9fffbf5 100644
--- a/libgui/bmp.c
+++ b/libgui/bmp.c
@@ -8,7 +8,7 @@
 
 struct bmp *bmp_load(const char *path)
 {
-	void *buf = read(path);
+	void *buf = sread(path);
 	if (!buf)
 		return NULL;
 
diff --git a/libgui/gfx.c b/libgui/gfx.c
index 0efedf9..3eb388a 100644
--- a/libgui/gfx.c
+++ b/libgui/gfx.c
@@ -51,10 +51,10 @@ static void load_font(enum font_type font_type)
 		path = FONT_64_PATH;
 		break;
 	default:
-		break;
+		return;
 	}
 
-	fonts[font_type] = psf_parse(read(path));
+	fonts[font_type] = psf_parse(sread(path));
 	assert(fonts[font_type]);
 }
 
diff --git a/libgui/png.c b/libgui/png.c
index 55999d9..2db6e4d 100644
--- a/libgui/png.c
+++ b/libgui/png.c
@@ -1166,15 +1166,17 @@ struct bmp *png_load(const char *path)
 	if (!png)
 		return NULL;
 
-	void *buf = read(path);
+	void *buf = sread(path);
 	if (!png) {
 		SET_ERROR(png, PNG_ENOTFOUND);
 		png_free(png);
 		return NULL;
 	}
 
+	struct stat s = { 0 };
+	stat(path, &s);
 	png->source.buffer = buf;
-	png->source.size = stat(path);
+	png->source.size = s.size;
 	png->source.owning = 1;
 
 	png_decode(png);
@@ -1188,6 +1190,7 @@ struct bmp *png_load(const char *path)
 	bmp->pitch = png->width * (bmp->bpp >> 3);
 
 	png_free(png);
+	free(buf);
 
 	return bmp;
 }
diff --git a/libgui/psf.c b/libgui/psf.c
index d6dc9c3..f7271a8 100644
--- a/libgui/psf.c
+++ b/libgui/psf.c
@@ -25,6 +25,9 @@ int psf_verify(char *data)
 
 struct font *psf_parse(char *data)
 {
+	if (!data)
+		return NULL;
+
 	int version = psf_verify(data);
 
 	char *chars;
diff --git a/libtxt/keymap.c b/libtxt/keymap.c
index ae2ab02..e03590e 100644
--- a/libtxt/keymap.c
+++ b/libtxt/keymap.c
@@ -26,7 +26,7 @@ void map(struct keymap *keymap, int line, char ch, int index)
 // Very ugly code but it should work for now
 struct keymap *keymap_parse(const char *path)
 {
-	char *keymap_src = read(path);
+	char *keymap_src = sread(path);
 	if (!keymap_src)
 		return NULL;
 	struct keymap *keymap = malloc(sizeof(*keymap));