1 files changed, 81 insertions, 53 deletions

diff --git a/kernel/src/fs/ext2.c b/kernel/src/fs/ext2.c
index 72eb776..7750a50 100644
--- a/kernel/src/fs/ext2.c
+++ b/kernel/src/fs/ext2.c
@@ -5,32 +5,34 @@
 #include <disc.h>
 #include <ext2.h>
 
-ext2_superblock_t* ext2_superblock;
+ext2_superblock_t *ext2_superblock;
 
-void read_block(uint32_t block_num, void* block_ptr)
+void read_block(uint32_t block_num, void *block_ptr)
 {
 	uint32_t sectors_per_block = BLOCK_SIZE / SECTOR_SIZE;
 
 	for (size_t i = 0; i < sectors_per_block; i++) {
-		read_sector(block_num * sectors_per_block + i, (disc_sector_t*)block_ptr + i);
+		read_sector(block_num * sectors_per_block + i,
+			    (disc_sector_t *)block_ptr + i);
 	}
 }
 
-void read_superblock(ext2_superblock_t* superblock)
+void read_superblock(ext2_superblock_t *superblock)
 {
 	char block[1024];
-	read_sector(2, (disc_sector_t*)block);
-	read_sector(3, (disc_sector_t*)block + 1);
+	read_sector(2, (disc_sector_t *)block);
+	read_sector(3, (disc_sector_t *)block + 1);
 	memcpy(superblock, block, sizeof(ext2_superblock_t));
 }
 
 void ext2_init()
 {
-	ext2_superblock = (ext2_superblock_t*)kalloc(sizeof(ext2_superblock_t));
+	ext2_superblock =
+		(ext2_superblock_t *)kalloc(sizeof(ext2_superblock_t));
 	read_superblock(ext2_superblock);
 }
 
-void read_bg_desc(uint32_t bg_desc, ext2_bg_desc_t* ext2_bg_desc)
+void read_bg_desc(uint32_t bg_desc, ext2_bg_desc_t *ext2_bg_desc)
 {
 	uint32_t starting_block_num = BLOCK_SIZE == 1024 ? 2 : 1;
 	uint32_t bg_descs_per_block = BLOCK_SIZE / BG_DESC_SIZE;
@@ -39,40 +41,44 @@ void read_bg_desc(uint32_t bg_desc, ext2_bg_desc_t* ext2_bg_desc)
 
 	char block[BLOCK_SIZE];
 	read_block(block_num, block);
-	memcpy(ext2_bg_desc, (char*)block + BG_DESC_SIZE * block_index, sizeof(ext2_bg_desc_t));
+	memcpy(ext2_bg_desc, (char *)block + BG_DESC_SIZE * block_index,
+	       sizeof(ext2_bg_desc_t));
 }
 
-void read_inode(uint32_t starting_block_num, uint32_t inode_index, ext2_inode_t* ext2_inode)
+void read_inode(uint32_t starting_block_num, uint32_t inode_index,
+		ext2_inode_t *ext2_inode)
 {
-	uint32_t block_num = starting_block_num + inode_index / INODES_PER_BLOCK;
+	uint32_t block_num =
+		starting_block_num + inode_index / INODES_PER_BLOCK;
 	uint32_t block_index = inode_index % INODES_PER_BLOCK;
 
 	char block[BLOCK_SIZE];
 	read_block(block_num, block);
-	memcpy(ext2_inode, (char*)block + block_index * INODE_SIZE, sizeof(ext2_inode_t));
+	memcpy(ext2_inode, (char *)block + block_index * INODE_SIZE,
+	       sizeof(ext2_inode_t));
 }
 
-dentry_list_t* directory_to_entries(uint32_t inode)
+dentry_list_t *directory_to_entries(uint32_t inode)
 {
-	dentry_list_t* dentry_list = (dentry_list_t*)kalloc(sizeof(dentry_list_t));
+	dentry_list_t *dentry_list =
+		(dentry_list_t *)kalloc(sizeof(dentry_list_t));
 	INIT_LIST(dentry_list->list);
 
 	if (inode < 2) {
 		return dentry_list;
 	}
 
-
 	uint32_t bg_desc = (inode - 1) / ext2_superblock->inodes_per_group;
 	uint32_t inode_index = (inode - 1) % ext2_superblock->inodes_per_group;
 
 	// block group descriptor
-	ext2_bg_desc_t* ext2_bg_desc;
-	ext2_bg_desc = (ext2_bg_desc_t*)kalloc(sizeof(ext2_bg_desc_t));
+	ext2_bg_desc_t *ext2_bg_desc;
+	ext2_bg_desc = (ext2_bg_desc_t *)kalloc(sizeof(ext2_bg_desc_t));
 	read_bg_desc(bg_desc, ext2_bg_desc);
 
 	// inode table
-	ext2_inode_t* ext2_inode;
-	ext2_inode = (ext2_inode_t*)kalloc(sizeof(ext2_inode_t));
+	ext2_inode_t *ext2_inode;
+	ext2_inode = (ext2_inode_t *)kalloc(sizeof(ext2_inode_t));
 	read_inode(ext2_bg_desc->inode_block_address, inode_index, ext2_inode);
 
 	// if it is not directory
@@ -91,8 +97,11 @@ dentry_list_t* directory_to_entries(uint32_t inode)
 		// parse block
 		for (size_t block_offset = 0; block_offset < BLOCK_SIZE;) {
 			// get dentry header
-			dentry_list_t* ext2_dentry_list = (dentry_list_t*)kalloc(sizeof(dentry_list_t));
-			memcpy(&ext2_dentry_list->ext2_dentry, (char*)block + block_offset, sizeof(ext2_dentry_t) - sizeof(char*));
+			dentry_list_t *ext2_dentry_list =
+				(dentry_list_t *)kalloc(sizeof(dentry_list_t));
+			memcpy(&ext2_dentry_list->ext2_dentry,
+			       (char *)block + block_offset,
+			       sizeof(ext2_dentry_t) - sizeof(char *));
 
 			// dentry is unused
 			if (ext2_dentry_list->ext2_dentry.inode == 0) {
@@ -101,26 +110,33 @@ dentry_list_t* directory_to_entries(uint32_t inode)
 			}
 
 			// get dentry name
-			ext2_dentry_list->ext2_dentry.name = (char*)kalloc(ext2_dentry_list->ext2_dentry.name_length_lower + 1);
-			memcpy(ext2_dentry_list->ext2_dentry.name, (char*)block + block_offset + sizeof(ext2_dentry_t) - sizeof(char*), ext2_dentry_list->ext2_dentry.name_length_lower);
-			ext2_dentry_list->ext2_dentry.name[ext2_dentry_list->ext2_dentry.name_length_lower] = '\0';
+			ext2_dentry_list->ext2_dentry.name = (char *)kalloc(
+				ext2_dentry_list->ext2_dentry.name_length_lower +
+				1);
+			memcpy(ext2_dentry_list->ext2_dentry.name,
+			       (char *)block + block_offset +
+				       sizeof(ext2_dentry_t) - sizeof(char *),
+			       ext2_dentry_list->ext2_dentry.name_length_lower);
+			ext2_dentry_list->ext2_dentry
+				.name[ext2_dentry_list->ext2_dentry
+					      .name_length_lower] = '\0';
 
 			// put dentry in list
-			add_to_list(&ext2_dentry_list->list, &dentry_list->list, dentry_list->list.next);
+			add_to_list(&ext2_dentry_list->list, &dentry_list->list,
+				    dentry_list->list.next);
 
 			// offset
 			block_offset += ext2_dentry_list->ext2_dentry.size;
 		}
 	}
 
-
 	kfree(ext2_bg_desc);
 	kfree(ext2_inode);
 
 	return dentry_list;
 }
 
-char* files_to_buffer(uint32_t inode)
+char *files_to_buffer(uint32_t inode)
 {
 	if (inode < 2) {
 		return NULL;
@@ -130,13 +146,13 @@ char* files_to_buffer(uint32_t inode)
 	uint32_t inode_index = (inode - 1) % ext2_superblock->inodes_per_group;
 
 	// block group descriptor
-	ext2_bg_desc_t* ext2_bg_desc;
-	ext2_bg_desc = (ext2_bg_desc_t*)kalloc(sizeof(ext2_bg_desc_t));
+	ext2_bg_desc_t *ext2_bg_desc;
+	ext2_bg_desc = (ext2_bg_desc_t *)kalloc(sizeof(ext2_bg_desc_t));
 	read_bg_desc(bg_desc, ext2_bg_desc);
 
 	// inode table
-	ext2_inode_t* ext2_inode;
-	ext2_inode = (ext2_inode_t*)kalloc(sizeof(ext2_inode_t));
+	ext2_inode_t *ext2_inode;
+	ext2_inode = (ext2_inode_t *)kalloc(sizeof(ext2_inode_t));
 	read_inode(ext2_bg_desc->inode_block_address, inode_index, ext2_inode);
 
 	if (ext2_inode->type_perms & TYPE_DIR) {
@@ -146,16 +162,18 @@ char* files_to_buffer(uint32_t inode)
 		return NULL;
 	}
 
-	char* data;
+	char *data;
 
 	uint32_t size = ext2_inode->size_lower;
-	data = (char*)kalloc(size + 1);
+	data = (char *)kalloc(size + 1);
 
 	uint32_t block_num = upper_div(size, BLOCK_SIZE);
 	for (size_t i = 0; i < min(block_num, 12); i++) {
 		char block[BLOCK_SIZE];
 		read_block(ext2_inode->dbp[i], block);
-		memcpy(data + i * BLOCK_SIZE, block, size >= (i + 1) * BLOCK_SIZE ? BLOCK_SIZE : size % BLOCK_SIZE);
+		memcpy(data + i * BLOCK_SIZE, block,
+		       size >= (i + 1) * BLOCK_SIZE ? BLOCK_SIZE :
+						      size % BLOCK_SIZE);
 	}
 	data[size] = '\0';
 
@@ -165,10 +183,10 @@ char* files_to_buffer(uint32_t inode)
 	return data;
 }
 
-path_t* path_to_list(const char* path)
+path_t *path_to_list(const char *path)
 {
 	size_t i, j;
-	path_t* divided_path = (path_t*)kalloc(sizeof(path_t));
+	path_t *divided_path = (path_t *)kalloc(sizeof(path_t));
 	INIT_LIST(divided_path->list)
 
 	size_t n = strlen(path);
@@ -176,19 +194,27 @@ path_t* path_to_list(const char* path)
 		if (i == n || path[i] == '/') {
 			// add data before slash
 			if (i != j) {
-				path_t* curr_path = (path_t*)kalloc(sizeof(path_t));
-				curr_path->name = (char*)kalloc(sizeof(char) * (uint32_t)(i - j + 1));
+				path_t *curr_path =
+					(path_t *)kalloc(sizeof(path_t));
+				curr_path->name = (char *)kalloc(
+					sizeof(char) * (uint32_t)(i - j + 1));
 				memcpy(curr_path->name, path + j, i - j);
 				curr_path->name[i - j] = '\0';
-				add_to_list(&curr_path->list, &divided_path->list, divided_path->list.next);
+				add_to_list(&curr_path->list,
+					    &divided_path->list,
+					    divided_path->list.next);
 			}
 			// add slash
 			if (i != n) {
-				path_t* curr_path = (path_t*)kalloc(sizeof(path_t));
-				curr_path->name = (char*)kalloc(sizeof(char) * 2);
+				path_t *curr_path =
+					(path_t *)kalloc(sizeof(path_t));
+				curr_path->name =
+					(char *)kalloc(sizeof(char) * 2);
 				curr_path->name[0] = '/';
 				curr_path->name[1] = '\0';
-				add_to_list(&curr_path->list, &divided_path->list, divided_path->list.next);
+				add_to_list(&curr_path->list,
+					    &divided_path->list,
+					    divided_path->list.next);
 				j = i + 1;
 			}
 		}
@@ -197,19 +223,19 @@ path_t* path_to_list(const char* path)
 	return divided_path;
 }
 
-uint32_t path_to_inode(const char* path)
+uint32_t path_to_inode(const char *path)
 {
 	uint32_t inode = 0;
-	path_t* divided_path = path_to_list(path);
+	path_t *divided_path = path_to_list(path);
 
 	// first entry is /
-	path_t* curr_path = list_prev_entry(divided_path, list);
+	path_t *curr_path = list_prev_entry(divided_path, list);
 	curr_path = list_prev_entry(curr_path, list);
 	inode = 2;
 
 	while (curr_path != divided_path) {
 		// list of dentry
-		dentry_list_t* dentry_list = directory_to_entries(inode);
+		dentry_list_t *dentry_list = directory_to_entries(inode);
 
 		// check if inode is actually a dir
 		if (list_is_empty((&dentry_list->list))) {
@@ -219,9 +245,10 @@ uint32_t path_to_inode(const char* path)
 
 		// iterate through all direntries
 		uint8_t ind = 1;
-		dentry_list_t* curr_dir;
-		list_for_each_entry_prev (curr_dir, (&dentry_list->list), list) {
-			if (!memcmp(curr_dir->ext2_dentry.name, curr_path->name)) {
+		dentry_list_t *curr_dir;
+		list_for_each_entry_prev(curr_dir, (&dentry_list->list), list) {
+			if (!memcmp(curr_dir->ext2_dentry.name,
+				    curr_path->name)) {
 				ind = 0;
 				inode = curr_dir->ext2_dentry.inode;
 				break;
@@ -240,7 +267,7 @@ uint32_t path_to_inode(const char* path)
 			curr_path = list_prev_entry(curr_path, list);
 	}
 
-	path_t* pos;
+	path_t *pos;
 	list_for_each_entry_del(pos, (&divided_path->list), list) {
 		kfree(pos->name);
 		kfree(pos);
@@ -252,15 +279,16 @@ uint32_t path_to_inode(const char* path)
 
 void ls(uint32_t inode)
 {
-	dentry_list_t* dir = directory_to_entries(inode);
+	dentry_list_t *dir = directory_to_entries(inode);
 	if (list_is_empty((&dir->list))) {
 		return;
 	}
 
 	printf("ls dir with inode %d:\n", inode);
-	dentry_list_t* pos;
+	dentry_list_t *pos;
 	list_for_each_entry(pos, (&dir->list), list) {
-		printf("inode: %d, name: %s\n", pos->ext2_dentry.inode, pos->ext2_dentry.name);
+		printf("inode: %d, name: %s\n", pos->ext2_dentry.inode,
+		       pos->ext2_dentry.name);
 	}
 
 	list_for_each_entry_del(pos, (&dir->list), list) {