Add ext2 VFS implementation
diff --git a/src/kernel/dri/fs/ext2/Jmk b/src/kernel/dri/fs/ext2/Jmk
index aac4c5c..8ad9344 100644
--- a/src/kernel/dri/fs/ext2/Jmk
+++ b/src/kernel/dri/fs/ext2/Jmk
@@ -1,3 +1,5 @@
+# -*- mode:makefile -*-
+
init(ext2, ext2.a)
preset(freestanding)
@@ -10,7 +12,7 @@
CFLAGS += -I$(ROOT)/include/kernel
-OBJECTS = ext2.o
+OBJECTS = ext2.o ext2_vfs.o
type(static_lib)
diff --git a/src/kernel/dri/fs/ext2/ext2.c b/src/kernel/dri/fs/ext2/ext2.c
index 9ecbe51..9952948 100644
--- a/src/kernel/dri/fs/ext2/ext2.c
+++ b/src/kernel/dri/fs/ext2/ext2.c
@@ -19,11 +19,6 @@
};
#undef F
-inline uint ext2_block_size(struct ext2_superblock *sb)
-{
- return 1024 << sb->block_size_shift;
-}
-
void ext2_read_block(struct ext2_superblock *sb, void *buffer, uint block)
{
uint block_size = ext2_block_size(sb) / 512;
@@ -68,9 +63,26 @@
}
}
-struct ext2_block_group_descriptor ext2_load_block_group_descriptor(
+void ext2_write_bgd(struct ext2_superblock *sb, uint block_group,
+ struct ext2_block_group_descriptor *d)
+{
+ ext2_load_or_write_bgd(sb, block_group, d, true);
+}
+
+struct ext2_block_group_descriptor ext2_load_bgd(
struct ext2_superblock *sb, uint block_group)
{
+ struct ext2_block_group_descriptor bgd;
+ ext2_load_or_write_bgd(sb, block_group, &bgd, false);
+
+ return bgd;
+}
+
+void ext2_load_or_write_bgd(struct ext2_superblock *sb,
+ uint block_group,
+ struct ext2_block_group_descriptor *d,
+ bool set)
+{
/**
* The BGDT (not to be confused with the GDT) is located the block after the
* superblock. On any block size EXCEPT 1024 (the minimum, remember that the
@@ -95,9 +107,17 @@
uint lba = (block_size / 512) * bgdt_block + hd_page;
- ata_pio_read_sectors(&descriptors, lba, 1);
+ ata_pio_read_sectors(descriptors, lba, 1);
- return descriptors[bgd_offset];
+ if (set)
+ {
+ descriptors[bgd_offset] = *d;
+ ata_pio_write_sectors(lba, 1, (ushort *)descriptors);
+ }
+ else
+ {
+ *d = descriptors[bgd_offset];
+ }
}
static bool print_entry(uint inode, const char *name, uint l, void *sb)
@@ -194,7 +214,7 @@
// Load this from the block group descriptor table
struct ext2_block_group_descriptor descriptor =
- ext2_load_block_group_descriptor(sb, block_group);
+ ext2_load_bgd(sb, block_group);
// We need to figure out what FS block the inode is on, we know how many
// inodes there are total in this BGD and the number per page, so this is
@@ -579,7 +599,7 @@
for (int bg_num = 0; bg_num < num_block_groups; bg_num++)
{
struct ext2_block_group_descriptor bgd =
- ext2_load_block_group_descriptor(sb, 0);
+ ext2_load_bgd(sb, 0);
const uint block_size = ext2_block_size(sb);
// + 1 because we need to round up (ie 1025 for 1024 size blocks will
@@ -609,7 +629,7 @@
for (int bg_num = 0; bg_num < num_block_groups; bg_num++)
{
struct ext2_block_group_descriptor bgd =
- ext2_load_block_group_descriptor(sb, 0);
+ ext2_load_bgd(sb, 0);
const uint block_size = ext2_block_size(sb);
// + 1 because we need to round up (ie 1025 for 1024 size blocks will
@@ -706,3 +726,25 @@
return d.inode;
}
+
+uint ext2_alloc_new_block(struct ext2_superblock *sb,
+ uint block_group)
+{
+ struct ext2_block_group_descriptor bgd =
+ ext2_load_bgd(sb, block_group);
+
+ if (bgd.unallocated_blocks == 0)
+ // TODO: handle out of blocks
+ return ext2_alloc_new_block(sb, block_group + 1);
+
+ // We can safely pass ~0 here as long as the FS is well formed
+ // because we know there is at least 1 free block
+ uint block = ext2_first_zero_bit(sb, bgd.block_bitmap, ~0, 0);
+
+ ext2_set_in_bitmap(sb, bgd.block_bitmap, block, true);
+ bgd.unallocated_blocks--;
+
+ ext2_write_bgd(sb, block_group, &bgd);
+
+ return block;
+}
diff --git a/src/kernel/dri/fs/ext2/ext2_vfs.c b/src/kernel/dri/fs/ext2/ext2_vfs.c
new file mode 100644
index 0000000..a612a4d
--- /dev/null
+++ b/src/kernel/dri/fs/ext2/ext2_vfs.c
@@ -0,0 +1,281 @@
+#include <dri/fs/ext2/ext2.h>
+#include <dri/fs/ext2/ext2_vfs.h>
+#include <sync.h>
+#include <alloc.h>
+#include <log.h>
+#include <io.h>
+
+struct ext2_fs_dirent
+{
+ struct fs_node *node;
+ char name[256];
+ uint name_len;
+ uint inode;
+
+ struct ext2_fs_dirent *next;
+};
+
+struct ext2_fs_data
+{
+ struct ext2_superblock *sb;
+
+ /// Cached inode
+ struct ext2_inode *in;
+
+ /// Reference count for the inode cache. Once this hits 0 we free
+ /// in. Only used for **files**, directories **always** cache
+ /// their inode.
+ uint rc;
+
+ semaphore_t lock;
+
+ /// Entries (if this is a directory)
+ struct ext2_fs_dirent *dirent;
+};
+
+uint ext2_file_read(struct fs_node *node, size_t ofs, size_t size,
+ uchar *buffer)
+{
+ struct ext2_fs_data *d = node->dri_res_p;
+ const uint block_size = ext2_block_size(d->sb);
+
+ // temporary buffer
+ uchar *tmp = malloc(block_size);
+
+ uint num_read = 0;
+
+ if (!buffer)
+ {
+ kprintf(WARN "ext2_file_read out of memory!\n");
+ return 0;
+ }
+
+ uint block_start = ofs / block_size;
+ uint block_offset = ofs % block_size;
+ int to_read;
+
+ do
+ {
+ // How much from this block to read
+ to_read = MIN(block_size - block_offset, size);
+ ext2_read_inode_block(d->sb, d->in, tmp, block_start);
+
+ // Copy that to the user buffer
+ memcpy(buffer, tmp + block_offset, to_read);
+ buffer += to_read;
+ size -= to_read;
+ num_read += to_read;
+
+ // Move to the next block
+ block_start++;
+ block_offset = 0;
+ }
+ while (to_read > 0);
+
+ free(tmp);
+ return num_read;
+}
+
+void ext2_file_open(struct fs_node *node)
+{
+ struct ext2_fs_data *d = node->dri_res_p;
+
+ sm_wait(d->lock);
+
+ if (d->rc++ == 0)
+ {
+ d->in = malloc(sizeof(struct ext2_inode));
+
+ if (d->in == NULL)
+ {
+ // lol
+ kpanic("ext2_file_open: ENOMEM");
+ }
+
+ if (!ext2_find_inode(d->sb, node->inode, d->in))
+ {
+ kprintf(ERROR "ext2_file_open: can't find inode %d\n",
+ node->inode);
+
+ free(d->in);
+ goto done;
+ }
+ }
+
+done:
+ sm_signal(d->lock);
+}
+
+void ext2_file_close(struct fs_node *node)
+{
+ struct ext2_fs_data *d = node->dri_res_p;
+
+ sm_wait(d->lock);
+
+ if (--d->rc == 0)
+ {
+ free(d->in);
+ d->in = NULL;
+ }
+
+ sm_signal(d->lock);
+}
+
+struct fs_vtable ext2_file_vfs_vt =
+{
+ .read = ext2_file_read,
+ .write = NULL,
+ .open = ext2_file_open,
+ .close = ext2_file_close,
+ .readdir = NULL,
+ .finddir = NULL,
+};
+
+bool ext2_dir_readdir(struct fs_node *node, uint index, struct fs_dirent *dirent)
+{
+ struct ext2_fs_data *d = node->dri_res_p;
+ struct ext2_fs_dirent *dent = d->dirent;
+
+ uint i;
+
+ for (i = 0; i < index && dent; i++, dent = dent->next)
+ {
+ }
+
+ if (i == index)
+ {
+ memcpy(dirent->name, dent->name, 256);
+ dirent->name_len = dent->name_len;
+ dirent->inode = dent->inode;
+
+ return true;
+ }
+
+ return false;
+}
+
+struct fs_node *ext2_dir_finddir(struct fs_node *node, char *name, uint name_len)
+{
+ name_len = MIN(name_len, 256);
+ struct ext2_fs_data *d = node->dri_res_p;
+ struct ext2_fs_dirent *dent = d->dirent;
+
+ for (; dent; dent = dent->next)
+ {
+ if (strncmp(dent->name, name, name_len) == 0)
+ {
+ return dent->node;
+ }
+ }
+
+ return NULL;
+}
+
+struct fs_vtable ext2_dir_vfs_vt =
+{
+ .read = NULL,
+ .write = NULL,
+ .open = NULL,
+ .close = NULL,
+ .readdir = ext2_dir_readdir,
+ .finddir = ext2_dir_finddir,
+};
+
+struct ext2_fs_dirent_to_fs_data
+{
+ struct ext2_fs_data *d;
+ struct ext2_fs_dirent *last;
+ struct ext2_superblock *sb;
+};
+
+static bool ext2_dirent_to_fs_node_cb(uint inode, const char *name,
+ uint name_len, void *data)
+{
+ struct ext2_fs_dirent_to_fs_data *d = data;
+
+ struct ext2_fs_dirent *dent =
+ malloc(sizeof(struct ext2_fs_dirent));
+
+ dent->node = ext2_inode2vfs(d->sb, inode, (char *)name, name_len);
+ dent->name_len = name_len;
+ memcpy(dent->name, name, MIN(name_len, 256));
+ dent->inode = inode;
+
+ if (d->last)
+ {
+ d->last->next = dent;
+ d->last = dent;
+ }
+ else
+ {
+ d->last = d->d->dirent = dent;
+ }
+
+ return true;
+}
+
+struct fs_node *ext2_inode2vfs(struct ext2_superblock *sb, uint inode,
+ char *name, uint name_len)
+{
+ struct ext2_inode in;
+
+ if (!ext2_find_inode(sb, inode, &in))
+ {
+ // Something has gone terribly wrong!
+ return NULL;
+ }
+
+ struct ext2_fs_data *d = malloc(sizeof(struct ext2_fs_data));
+
+ d->sb = sb;
+ d->rc = 0;
+ d->lock = sm_new();
+ d->in = NULL;
+ d->dirent = NULL;
+
+ struct fs_node *n = malloc(sizeof(struct fs_node));
+
+ n->name_len = MIN(name_len, FS_MAX_NAME_LEN);
+ memcpy(n->name, name, n->name_len);
+ n->inode = inode;
+ n->dri_res_p = d;
+
+ n->mask = in.mode & 0xfff;
+ n->gid = in.gid;
+ n->uid = in.uid;
+ n->size = in.size;
+
+ switch (in.mode & EXT2_F_TYPE)
+ {
+ case EXT2_S_IFREG:
+ {
+ n->flags = FS_FILE;
+ n->vtable = &ext2_file_vfs_vt;
+
+ break;
+ }
+
+ case EXT2_S_IFDIR:
+ {
+ n->flags = FS_DIRECTORY;
+ n->vtable = &ext2_dir_vfs_vt;
+
+ struct ext2_fs_dirent_to_fs_data data;
+ data.d = d;
+ data.last = NULL;
+
+ ext2_dir_ls(sb, &in, ext2_dirent_to_fs_node_cb, &data);
+
+ break;
+ }
+
+ default:
+ {
+ kprintf(ERROR "ext2_inode2vfs: unimplemented for dir type%d\n",
+ EXT2_S_TO_FT(in.mode));
+ kpanic("Unimplemented");
+ }
+ }
+
+ return n;
+}