spz-lab4/src/fs.c

#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <stdlib.h>

#include "print.h"
#include "fs.h"

#include "config.h"

const static int BLOCK_ADDRESSES_PER_INODE = (FS_BLOCK_SIZE-sizeof(int)*3) / sizeof(int);
const static int BLOCK_ADDRESSES_PER_INODE_EXTENSION = (FS_BLOCK_SIZE-sizeof(int)) / sizeof(int);
const static int DIRECTORY_RECORDS_PER_BLOCK = FS_BLOCK_SIZE / sizeof(struct fs_directory_record);


static char used_file_path[FS_MAX_DEVICE_FILE_NAME_LEN+1];
static int used_file_fd;
static int write_permitted;

static char fs_cwd[FS_MAX_PATH_LEN+1];
static unsigned int fs_cwd_inode_ptr;

static struct fs_file_description fs_file_descriptions[FS_MAX_OPEN_FD];

static int extract_basename(char *path, char *name);


static int read_block(unsigned int block_no, void *data)
{
	// failsafe
	struct stat st;
	if (fstat(used_file_fd, &st) < 0) {
		pr_err("could not stat device '%s'\n", used_file_path);
		return 0;
	}

	if (block_no * FS_BLOCK_SIZE >= st.st_size) {
		pr_err("read beyond device address space denied (%d >= %ld)\n",
				block_no * FS_BLOCK_SIZE, st.st_size);
		return -1;
	}

	if (lseek(used_file_fd, block_no * FS_BLOCK_SIZE, SEEK_SET) < 0) {
		pr_err("failed to seek to block %d (bs=%d) on device '%s'\n", block_no, FS_BLOCK_SIZE, used_file_path);
		return -1;
	}

	return read(used_file_fd, data, FS_BLOCK_SIZE);
}

static int write_block(unsigned int block_no, void *data)
{
	// failsafe
	struct stat st;
	if (fstat(used_file_fd, &st) < 0) {
		pr_err("could not stat device '%s'\n", used_file_path);
		return 0;
	}

	if (block_no * FS_BLOCK_SIZE >= st.st_size) {
		pr_err("write beyond device address space denied (%d >= %ld)\n",
				block_no * FS_BLOCK_SIZE, st.st_size);
		return -1;
	}

	if (!write_permitted) {
		pr_err("write operations are prohibited\n");
		return -1;
	}

	if (lseek(used_file_fd, block_no * FS_BLOCK_SIZE, SEEK_SET) < 0) {
		pr_err("failed to seek to block %d (bs=%d) on device '%s'\n", block_no, FS_BLOCK_SIZE, used_file_path);
		return -1;
	}

	return write(used_file_fd, data, FS_BLOCK_SIZE);
}

static void mark_used(unsigned int block_no)
{
	struct fs_header fsh;
	read_block(0, (void *) &fsh);

	if (block_no > fsh.block_count) {
		pr_err("block %d is out of filesystem block range (%d)\n", block_no, fsh.block_count);
		return;
	}

	unsigned char bitmap_bit = 1 << (block_no & 0x7);
	unsigned int bitmap_block_offset = (block_no >> 3) % FS_BLOCK_SIZE;
	unsigned int bitmap_block_index = (block_no >> 3) / FS_BLOCK_SIZE;

	unsigned char bitmap_block[FS_BLOCK_SIZE];
	read_block(bitmap_block_index+1, (void *) bitmap_block);

	bitmap_block[bitmap_block_offset] |= bitmap_bit;

	// write changes to device
	write_block(bitmap_block_index+1, (void *) &bitmap_block);

	pr("Marked block_no=%d (block=%d, offset=%d, bit=%d) as used\n",
			block_no, bitmap_block_index, bitmap_block_offset, block_no & 0x7);
}

static void mark_free(unsigned int block_no)
{
	struct fs_header fsh;
	read_block(0, (void *) &fsh);

	if (block_no > fsh.block_count) {
		pr_err("block %d is out of filesystem block range (%d)\n", block_no, fsh.block_count);
		return;
	}

	unsigned char bitmap_bit = 1 << (block_no & 0x7);
	unsigned int bitmap_block_offset = (block_no >> 3) % FS_BLOCK_SIZE;
	unsigned int bitmap_block_index = (block_no >> 3) / FS_BLOCK_SIZE;

	unsigned char bitmap_block[FS_BLOCK_SIZE];
	read_block(bitmap_block_index+1, (void *) bitmap_block);

	bitmap_block[bitmap_block_offset] &= ~bitmap_bit;

	// write changes to device
	write_block(bitmap_block_index+1, (void *) bitmap_block);

	pr("Marked block_no=%d (block=%d, offset=%d, bit=%d) as free\n",
			block_no, bitmap_block_index, bitmap_block_offset, block_no & 0x7);
}

static int identify_fs(void)
{
	struct fs_header read_buf;
	{
		int read_amount = read_block(0, (void *) &read_buf);

		if (read_amount < 0) {
			pr_err("failed to read fs_header from storage device '%s'\n", used_file_path);
			return 0;
		}

		if (read_amount < FS_BLOCK_SIZE) {
			pr_warn("failed to read full block (read %d/%d bytes)\n", read_amount, FS_BLOCK_SIZE);
		} else if (read_amount == 0) {
			pr_err("storage device size is 0\n");
			return 0;
		}
	}

	if (read_buf.next_extension) {
		pr_info("identified filesystem version 0x%hhx with %d max inodes (on %d blocks), next header extension is at block 0x%x\n",
				read_buf.version, read_buf.max_inode_count, read_buf.block_count, read_buf.next_extension);
	} else {
		pr_info("identified filesystem version 0x%hhx with %d max inodes (on %d blocks), with no header extensions\n",
				read_buf.version, read_buf.max_inode_count, read_buf.block_count);
	}

	return read_buf.version;
}

static unsigned int find_free_block(void)
{
	unsigned int b = 0;

	struct fs_header fsh;
	read_block(0, (void *) &fsh);

	int blocks_used_for_bitmap = fsh.block_count / (FS_BLOCK_SIZE * 8);
	if (fsh.block_count % (FS_BLOCK_SIZE * 8))
		blocks_used_for_bitmap++;

	for (int i = 0; i < blocks_used_for_bitmap; i++) {
		unsigned char bitmap_block[FS_BLOCK_SIZE];
		read_block(i+1, (void *) bitmap_block);

		for (int j = 0; j < FS_BLOCK_SIZE; j++) {
			if (!(~(bitmap_block[j]))) {
				b += 8;
			} else {
				for (int k = 0; k < 8; k++, b++) {
					if (!((bitmap_block[j]) & (1 << k))) {
						return b;
					}
				}
			}
		}
	}

	return 0;
}

static unsigned int find_free_inode_ptr(void)
{
	unsigned int i = 1;  // inode0 always points to root dir, so can't be free

	struct fs_header fsh;
	read_block(0, (void *) &fsh);

	// search fs_header
	for ( ; i < BLOCK_ADDRESSES_PER_INODE; i++) {
		if (fsh.inode_ptrs[i] == 0) {
			if (i < fsh.max_inode_count) {
				return i;
			} else {
				return 0;
			}
		}
	}

	// search fs_header_extensions
	struct fs_header_extension ext;
	unsigned int next_extension = fsh.next_extension;

	while (next_extension) {
		read_block(next_extension, (void *) &ext);
		next_extension = ext.next_extension;

		for (int j = 0; j < BLOCK_ADDRESSES_PER_INODE_EXTENSION; j++, i++) {
			if (ext.inode_ptrs[j] == 0) {
				if (i < fsh.max_inode_count) {
					return i;
				} else {
					return 0;
				}
			}
		}
	}

	if (i < fsh.max_inode_count) {
		return i;
	} else {
		return 0;
	}
}

static unsigned int read_inode_ptr(unsigned int inode_ptr)
{
	if ((inode_ptr / BLOCK_ADDRESSES_PER_INODE) == 0) {
		// inode_ptr is in the fs_header
		struct fs_header fsh;
		int read_result = read_block(0, &fsh);
		if (FS_BLOCK_SIZE != read_result) {
			if (read_result < 0) {
				pr_err("failed to read fs header from device '%s'\n", used_file_path);
			} else {
				pr_err("failed to read full header from device (read %d/%d bytes)\n", read_result, FS_BLOCK_SIZE);
			}

			return 0;
		}

		return fsh.inode_ptrs[inode_ptr];
	} else {
		// inode_ptr is in fs_header_extension
		int extension_no = (inode_ptr - BLOCK_ADDRESSES_PER_INODE) / BLOCK_ADDRESSES_PER_INODE_EXTENSION;
		int extension_offset = (inode_ptr - BLOCK_ADDRESSES_PER_INODE) % BLOCK_ADDRESSES_PER_INODE_EXTENSION;

		struct fs_header fsh;
		int read_result = read_block(0, &fsh);
		if (FS_BLOCK_SIZE != read_result) {
			if (read_result < 0) {
				pr_err("failed to read fs header from device '%s'\n", used_file_path);
			} else {
				pr_err("failed to read full header from device (read %d/%d bytes)\n", read_result, FS_BLOCK_SIZE);
			}

			return 0;
		}

		if (!fsh.next_extension)
			return 0;

		unsigned int next_ext = fsh.next_extension;
		unsigned int curr_ext = 0;

		struct fs_header_extension ext;

		for (unsigned int i = 0; i < extension_no + 1; i++) {
			if (!next_ext)
				return 0;

			curr_ext = next_ext;
			read_block(curr_ext, (void *) &ext);
			next_ext = ext.next_extension;
		}

		return ext.inode_ptrs[extension_offset];
	}
}

static void write_inode_ptr(unsigned int inode_ptr, unsigned int block_ptr)
{
	if ((inode_ptr / BLOCK_ADDRESSES_PER_INODE) == 0) {
		// inode_ptr is in the fs_header
		struct fs_header fsh;
		int read_result = read_block(0, &fsh);
		if (FS_BLOCK_SIZE != read_result) {
			if (read_result < 0) {
				pr_err("failed to read fs header from device '%s'\n", used_file_path);
			} else {
				pr_err("failed to read full header from device (read %d/%d bytes)\n", read_result, FS_BLOCK_SIZE);
			}

			return;
		}

		fsh.inode_ptrs[inode_ptr] = block_ptr;

		int write_result = write_block(0, (void *) &fsh);
		if (FS_BLOCK_SIZE != write_result) {
			if (write_result < 0) {
				pr_err("failed to write fs header to device '%s'\n", used_file_path);
			} else {
				pr_err("failed to write full block to device, written %d/%d bytes\n", write_result, FS_BLOCK_SIZE);
			}

			return;
		}

		pr("Updated inode ptr %d -> %d\n", inode_ptr, block_ptr);
	} else {
		// inode_ptr is in fs_header_extension
		int extension_no = (inode_ptr - BLOCK_ADDRESSES_PER_INODE) / BLOCK_ADDRESSES_PER_INODE_EXTENSION;
		int extension_offset = (inode_ptr - BLOCK_ADDRESSES_PER_INODE) % BLOCK_ADDRESSES_PER_INODE_EXTENSION;

		struct fs_header fsh;
		int read_result = read_block(0, &fsh);
		if (FS_BLOCK_SIZE != read_result) {
			if (read_result < 0) {
				pr_err("failed to read fs header from device '%s'\n", used_file_path);
			} else {
				pr_err("failed to read full header from device (read %d/%d bytes)\n", read_result, FS_BLOCK_SIZE);
			}

			return;
		}

		// special case: if header has no extensions, create one
		// if it was not needed, we would not have ended here in the first place
		if (!fsh.next_extension) {
			unsigned int new_block = find_free_block();
			if (!new_block) {
				pr_err("failed to allocate block for fs_header_extension\n");
				return;
			}
			mark_used(new_block);

			struct fs_header_extension ext;
			memset(&ext, 0, sizeof(struct fs_header_extension));
			write_block(new_block, (void *) &ext);

			fsh.next_extension = new_block;
			write_block(0, (void *) &fsh);
		}

		unsigned int next_ext = fsh.next_extension;
		unsigned int curr_ext = 0;

		struct fs_header_extension ext;

		for (unsigned int i = 0; i < extension_no + 1; i++) {
			if (!next_ext) {
				unsigned int new_block = find_free_block();
				if (!new_block) {
					pr_err("failed to allocate block for fs_header_extension\n");
					return;
				}
				mark_used(new_block);

				struct fs_header_extension new_ext;
				memset(&new_ext, 0, sizeof(struct fs_header_extension));
				write_block(new_block, (void *) &new_ext);

				ext.next_extension = new_block;
				write_block(curr_ext, (void *) &ext);

				next_ext = new_block;
			}

			curr_ext = next_ext;
			read_block(curr_ext, (void *) &ext);
			next_ext = ext.next_extension;
		}

		ext.inode_ptrs[extension_offset] = block_ptr;
		write_block(curr_ext, (void *) &ext);

		pr("Updated inode ptr %d -> %d\n", inode_ptr, block_ptr);
	}
}

char *fs_get_cwd(void)
{
	return fs_cwd;
}

int fs_chdir(void *d)
{
	memset(fs_cwd, 0, sizeof(fs_cwd));
	strcpy(fs_cwd, *((char**)d));

	return 0;
}

int fs_allow_write(void *d)
{
	if (used_file_fd <= 0) {
		pr_err("no device present\n");
		return 0;
	}

	pr_info("Allowing write operations on device '%s'\n", used_file_path);
	write_permitted = 1;

	return 0;
}

int fs_prohibit_write(void *d)
{
	if (used_file_fd <= 0) {
		pr_err("no device present\n");
		return 0;
	}

	pr_info("Prohibiting write operations on device '%s'\n", used_file_path);
	write_permitted = 0;

	return 0;
}

static int fs_find_free_directory_record(unsigned int dir_inode_ptr)
{
	struct fs_header fsh;
	read_block(0, (void *) &fsh);

	struct fs_inode dir;
	read_block(read_inode_ptr(dir_inode_ptr), (void *) &dir);

	int found_block_no = 0;

	// search in base inode
	for (unsigned int i = 0; i < BLOCK_ADDRESSES_PER_INODE; i++) {
		struct fs_directory_record r[DIRECTORY_RECORDS_PER_BLOCK];

		if (!dir.blocks[i]) {
			if (found_block_no < fsh.max_inode_count)
				return found_block_no;
			else
				return -1;
		}

		read_block(dir.blocks[i], (void *) &r);

		for (int j = 0; j < DIRECTORY_RECORDS_PER_BLOCK; j++, found_block_no++) {
			if (r[j].fname[0])
				continue;

			if (found_block_no >= fsh.max_inode_count)
				return -1;

			return found_block_no;
		}
	}

	// search in inode extensions
	struct fs_inode_extension ext;

	unsigned int next_ext = dir.next_extension;

	while (next_ext) {
		read_block(next_ext, (void *) &ext);
		next_ext = ext.next_extension;

		for (unsigned int i = 0; i < BLOCK_ADDRESSES_PER_INODE_EXTENSION; i++) {
			struct fs_directory_record r[DIRECTORY_RECORDS_PER_BLOCK];

			if (!ext.blocks[i]) {
				if (found_block_no < fsh.max_inode_count)
					return found_block_no;
				else
					return -1;
			}

			read_block(ext.blocks[i], (void *) &r);

			for (int j = 0; j < DIRECTORY_RECORDS_PER_BLOCK; j++, found_block_no++) {
				if (r[j].fname[0])
					continue;

				if (found_block_no >= fsh.max_inode_count)
					return -1;

				return found_block_no;
			}
		}
	}

	if (found_block_no >= fsh.max_inode_count)
		return -1;
	else
		return found_block_no;
}

static int *find_filename_in_directory(unsigned int dir_inode_ptr, char *fname)
{
	int dir_inode = read_inode_ptr(dir_inode_ptr);

	struct fs_inode dir;
	read_block(dir_inode, (void *) &dir);

	// list entries from base inode
	for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE; i++) {
		struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];

		if (dir.blocks[i]) {
			read_block(dir.blocks[i], (void *) &recs);

			for (int k = 0; k < DIRECTORY_RECORDS_PER_BLOCK; k++) {
				if (!recs[k].fname[0])
					continue;

				if (strcmp(fname, recs[k].fname))
					continue;

				// filename found
				int *r = malloc(sizeof(int) * 3);
				r[0] = i;
				r[1] = k;
				r[2] = recs[k].inode_no;
				return r;
			}
		}
	}

	// list entries from inode extensions
	struct fs_inode_extension ext;
	unsigned int next_ext = dir.next_extension;

	while (next_ext) {
		read_block(next_ext, (void *) &ext);
		next_ext = ext.next_extension;

		for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE_EXTENSION; i++) {
			struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];

			if (ext.blocks[i]) {
				read_block(ext.blocks[i], (void *) &recs);

				for (int k = 0; k < DIRECTORY_RECORDS_PER_BLOCK; k++) {
					if (!recs[k].fname[0])
						continue;

					if (strcmp(fname, recs[k].fname))
						continue;

					// filename found
					int *r = malloc(sizeof(int) * 3);
					r[0] = i;
					r[1] = k;
					r[2] = recs[k].inode_no;
					return r;
				}
			}
		}
	}

	return NULL;
}

static int find_fname_in_directory(unsigned int dir_inode_ptr, char *fname)
{
	int *r = find_filename_in_directory(dir_inode_ptr, fname);
	int res;

	if (r) {
		res = r[2];
		free(r);
	} else {
		res = -1;
	}

	return res;
}

static int inode_is_referenced(unsigned int inode)
{
	struct fs_inode f;
	read_block(inode, (void *) &f);

	if (f.ref_count)
		return 1;

	for (int i = 0; i < FS_MAX_OPEN_FD; i++)
		if (fs_file_descriptions[i].inode == inode)
			return 1;

	return 0;
}

static void clean_inode(unsigned int inode)
{
	pr("Removing all data related to inode=%d\n", inode);

	struct fs_inode f;
	read_block(inode, (void *) &f);

	// clear blocks referenced in base inode
	for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE; i++) {
		if (f.blocks[i])
			mark_free(f.blocks[i]);
	}
	mark_free(inode);

	// clear blocks referenced in inode extensions
	struct fs_inode_extension ext;
	unsigned int next_extension = f.next_extension;

	while (next_extension) {
		mark_free(next_extension);
		read_block(next_extension, (void *) &ext);
		next_extension = ext.next_extension;

		for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE_EXTENSION; i++) {
			if (ext.blocks[i])
				mark_free(ext.blocks[i]);
		}
	}
}

static int fs_add_fname_to_directory(unsigned int dir_inode_ptr, unsigned int target_inode_ptr, char *fname)
{
	{
		// check if duplicate filename exists in specified directory
		int *r = find_filename_in_directory(dir_inode_ptr, fname);
		if (r) {
			free(r);
			pr_err("filename '%s' already exists\n", fname);
			return -1;
		}
	}

	int new_directory_record_index = fs_find_free_directory_record(dir_inode_ptr);
	if (new_directory_record_index < 0) {
		pr_err("no free directory record found\n");
		return -1;
	}

	struct fs_inode dir;
	read_block(read_inode_ptr(dir_inode_ptr), (void *) &dir);

	if (new_directory_record_index < DIRECTORY_RECORDS_PER_BLOCK * BLOCK_ADDRESSES_PER_INODE) {
		// record is located in base inode, writing to it
		int block_no = new_directory_record_index / DIRECTORY_RECORDS_PER_BLOCK;
		int block_offset = new_directory_record_index % DIRECTORY_RECORDS_PER_BLOCK;

		if (dir.blocks[block_no] == 0) {
			// allocate new block
			unsigned int new_block = find_free_block();
			if (new_block == 0) {
				pr_err("failed to allocate block to extend directory (inode_ptr=%d)\n", dir_inode_ptr);
				return -1;
			} else {
				pr("Allocated new physical block %d for inode_ptr=%d (inode=%d, inner_block_no=%d)\n",
						new_block, dir_inode_ptr, read_inode_ptr(dir_inode_ptr), block_no);
			}

			char zero_data[FS_BLOCK_SIZE] = {0};
			memset(zero_data, 0, FS_BLOCK_SIZE);
			write_block(new_block, &zero_data);

			mark_used(new_block);

			dir.blocks[block_no] = new_block;
			if (dir.size <= block_no * FS_BLOCK_SIZE) {
				pr("Updated directory size at inode_ptr=%d: %d -> %d\n",
						dir_inode_ptr, dir.size, (block_no + 1) * FS_BLOCK_SIZE);
				dir.size = (block_no + 1) * FS_BLOCK_SIZE;
				write_block(read_inode_ptr(dir_inode_ptr), (void *) &dir);
			}
		}

		struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];
		read_block(dir.blocks[block_no], (void *) &recs);

		strcpy(recs[block_offset].fname, fname);
		recs[block_offset].inode_no = target_inode_ptr;

		write_block(dir.blocks[block_no], (void *) &recs);

		pr("Written new directory record #%d for file '%s' (-> inode_ptr=%d) in inode_ptr=%d\n",
				new_directory_record_index, fname, target_inode_ptr, dir_inode_ptr);
	} else {
		// record is located in inode extension
		unsigned int extension_no = (new_directory_record_index - (DIRECTORY_RECORDS_PER_BLOCK * BLOCK_ADDRESSES_PER_INODE))
			/ (DIRECTORY_RECORDS_PER_BLOCK * BLOCK_ADDRESSES_PER_INODE_EXTENSION);
		unsigned int extension_block_index = (new_directory_record_index - (DIRECTORY_RECORDS_PER_BLOCK * BLOCK_ADDRESSES_PER_INODE))
			% (DIRECTORY_RECORDS_PER_BLOCK * BLOCK_ADDRESSES_PER_INODE_EXTENSION);
		unsigned int extension_block_offset = (new_directory_record_index - (DIRECTORY_RECORDS_PER_BLOCK * BLOCK_ADDRESSES_PER_INODE))
			% DIRECTORY_RECORDS_PER_BLOCK;

		// seek to next extension
		// special case
		if (!dir.next_extension) {
			unsigned int new_block = find_free_block();
			if (!new_block) {
				pr_err("failed to allocate block for fs_inode_extension\n");
				return -1;
			}
			mark_used(new_block);

			struct fs_inode_extension ext;
			memset(&ext, 0, sizeof(struct fs_inode_extension));
			write_block(new_block, (void *) &ext);

			dir.next_extension = new_block;
			write_block(read_inode_ptr(dir_inode_ptr), (void *) &dir);
		}

		struct fs_inode_extension ext;
		unsigned int next_ext = dir.next_extension;
		unsigned int curr_ext = 0;

		for (int i = 0; i < extension_no + 1; i++) {
			if (!next_ext) {
				unsigned int new_block = find_free_block();
				if (!new_block) {
					pr_err("failed to allocate block for fs_inode_extension\n");
					return -1;
				}
				mark_used(new_block);

				struct fs_inode_extension new_ext;
				memset(&new_ext, 0, sizeof(struct fs_inode_extension));
				write_block(new_block, (void *) &new_ext);

				ext.next_extension = new_block;
				write_block(curr_ext, (void *) &ext);

				next_ext = new_block;
			}

			curr_ext = next_ext;
			read_block(curr_ext, (void *) &ext);
			next_ext = ext.next_extension;
		}

		struct fs_directory_record r[DIRECTORY_RECORDS_PER_BLOCK];

		if (!ext.blocks[extension_block_index]) {
			unsigned int new_block = find_free_block();
			if (!new_block) {
				pr_err("failed to allocate block for file data\n");
				return -1;
			}
			mark_used(new_block);

			ext.blocks[extension_block_index] = new_block;
			write_block(curr_ext, (void *) &ext);

			memset(&r, 0, sizeof(r));

			unsigned int dir_size = BLOCK_ADDRESSES_PER_INODE * FS_BLOCK_SIZE
				+ extension_no * BLOCK_ADDRESSES_PER_INODE_EXTENSION * FS_BLOCK_SIZE
				+ (extension_block_index + 1) * FS_BLOCK_SIZE;
			if (dir.size < dir_size) {
				dir.size = dir_size;
				write_block(read_inode_ptr(dir_inode_ptr), (void *) &dir);
			}
		} else {
			read_block(ext.blocks[extension_block_index], (void *) &r);
		}

		r[extension_block_offset].inode_no = target_inode_ptr;
		strcpy(r[extension_block_offset].fname, fname);
		write_block(ext.blocks[extension_block_index], (void *) &r);

		pr("Written new directory record #%d for file '%s' (-> inode_ptr=%d) in inode_ptr=%d\n",
				new_directory_record_index, fname, target_inode_ptr, dir_inode_ptr);
	}

	return 0;
}

static void fs_remove_fname_from_directory_removal(struct fs_directory_record *recs, unsigned int k, unsigned int dir_block_addr)
{
	unsigned int inode_ptr_cache = recs[k].inode_no;
	unsigned int inode_location_cache = read_inode_ptr(recs[k].inode_no);

	// decrement ref_count
	struct fs_inode f;
	read_block(read_inode_ptr(recs[k].inode_no), &f);
	f.ref_count--;
	write_block(read_inode_ptr(recs[k].inode_no), &f);

	// clear directory record inode_ptr
	recs[k].fname[0] = 0;
	write_block(dir_block_addr, recs);

	// if it drops to zero, nullify inode_ptr pointing to this inode
	if (f.ref_count)
		return;

	pr("ref_count=0, clearing inode_ptr\n");
	write_inode_ptr(inode_ptr_cache, 0);

	// if no fd reference this inode, clean it up altogether
	int i;
	for (i = 0; i < FS_MAX_OPEN_FD; i++)
		if (fs_file_descriptions[i].inode == inode_location_cache)
			break;

	if (i != FS_MAX_OPEN_FD) {
		pr("Inode %d is still referenced by fd %d, not removing it\n",
				inode_location_cache, i);
		return;
	}

	pr("No open fd reference inode %d, cleaning up\n", inode_location_cache);

	clean_inode(inode_location_cache);
}

static int fs_remove_fname_from_directory(unsigned int dir_inode_ptr, char *fname)
{
	struct fs_inode dir;
	read_block(read_inode_ptr(dir_inode_ptr), &dir);

	// list entries from base inode
	for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE; i++) {
		struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];

		if (!dir.blocks[i])
			continue;

		read_block(dir.blocks[i], &recs);

		for (int k = 0; k < DIRECTORY_RECORDS_PER_BLOCK; k++) {
			if (!recs[k].fname[0])
				continue;

			if (strcmp(fname, recs[k].fname))
				continue;

			pr("Directory record for '%s' found in block=%d, record=%d, removing\n", fname, i, k);

			fs_remove_fname_from_directory_removal(recs, k, dir.blocks[i]);

			goto fs_remove_fname_from_directory_finish;
		}
	}

	// list entries from inode extension
	struct fs_inode_extension ext;

	unsigned int next_ext = dir.next_extension;
	unsigned int curr_ext = 0;

	unsigned int ext_no = 0;

	while (next_ext) {
		ext_no++;
		curr_ext = next_ext;
		read_block(curr_ext, (void *) &ext);
		next_ext = ext.next_extension;

		for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE_EXTENSION; i++) {
			struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];

			if (!ext.blocks[i])
				continue;

			read_block(ext.blocks[i], (void *) &recs);

			for (int k = 0; k < DIRECTORY_RECORDS_PER_BLOCK; k++) {
				if (!recs[k].fname[0])
					continue;

				if (strcmp(fname, recs[k].fname))
					continue;

				pr("Directory record for '%s' found in ext=%d, block=%d, record=%d, removing\n",
						fname, ext_no, i, k);

				fs_remove_fname_from_directory_removal(recs, k, ext.blocks[i]);

				goto fs_remove_fname_from_directory_finish;
			}
		}
	}

	pr_err("no such file '%s'\n", fname);
	return -1;

fs_remove_fname_from_directory_finish:
	pr("Removed fname from directory record successfully\n");
	return 0;
}

static void resolve_path(struct resolved_path *rp, char *path, unsigned int params)
{
	rp->parent_inode_ptr = -1;
	rp->target_inode_ptr = -1;

	int path_len = strlen(path);

	if (!path_len) {
		pr_err("no path specified\n");
		return;
	}

	if (!strcmp(path, "/")) {
		rp->parent_inode_ptr = 0;
		rp->target_inode_ptr = 0;
		strcpy(rp->parent_fname, "/");
		strcpy(rp->target_fname, "/");
		return;
	}

	char current_fname[FS_MAX_FNAME_LEN+1] = {0};
	int current_inode_ptr;
	int i;

	if (path[0] == '/') {
		current_inode_ptr = 0;
		rp->parent_inode_ptr = 0;
		strcpy(current_fname, "/");
		i = 1;
	} else {
		current_inode_ptr = fs_cwd_inode_ptr;
		rp->parent_inode_ptr = fs_cwd_inode_ptr;
		extract_basename(fs_cwd, current_fname);
		i = 0;
	}

	char next_fname[FS_MAX_FNAME_LEN+1] = {0};
	int next_fname_ptr = 0;

	for ( ; i < path_len; i++) {
		if (path[i] != '/') {
			next_fname[next_fname_ptr] = path[i];
			next_fname_ptr++;
			continue;
		}

		// path[i] == '/', trying to change current directory

		if (!next_fname_ptr)
			continue;

		if (i+1 == path_len)
			continue;

		{
			int res = find_fname_in_directory(current_inode_ptr, next_fname);
			if (res < 0) {
				pr_warn("directory '%s' does not exist\n", next_fname);
				rp->parent_inode_ptr = -1;
				break;
			}

			{
				struct fs_inode d;
				read_block(read_inode_ptr(res), &d);

				if (d.ftype == REGULAR) {
					pr_warn("'%s' is a regular file\n", next_fname);
					rp->parent_inode_ptr = -1;
					break;
				}
			}

			pr("Found directory '%s'\n", next_fname);
			current_inode_ptr = res;
			rp->parent_inode_ptr = res;
		}

		next_fname_ptr = 0;
		strcpy(current_fname, next_fname);
		memset(next_fname, 0, FS_MAX_FNAME_LEN);
	}

	if (rp->parent_inode_ptr < 0) {
		rp->target_inode_ptr = -1;
		return;
	}

	strcpy(rp->parent_fname, current_fname);

	{
		int res = find_fname_in_directory(current_inode_ptr, next_fname);
		if (res < 0) {
			pr_warn("target fname '%s' does not exist\n", next_fname);
			rp->target_inode_ptr = -1;
		} else {
			rp->target_inode_ptr = res;
			strcpy(rp->target_fname, next_fname);
		}
	}

	return;
}


static int find_free_fd(void)
{
	for (int i = 0; i < FS_MAX_OPEN_FD; i++)
		if (!fs_file_descriptions[i].inode)
			return i;

	return -1;
}

int fs_open(void *d)
{
	char *path = *((char **) d);

	struct resolved_path rp;
	resolve_path(&rp, path, FOLLOW_LAST_SYMLINK);

	if (rp.target_inode_ptr < 0) {
		pr_err("no such file: '%s'\n", path);
		return 0;
	}

	int free_fd = find_free_fd();
	if (free_fd < 0) {
		pr_err("no free file descriptor found\n");
		return 0;
	}

	fs_file_descriptions[free_fd].inode = rp.target_inode_ptr;
	fs_file_descriptions[free_fd].rw_offset = 0;

	pr_stdout("%d\n", free_fd);

	return 0;
}

int fs_seek(void *d)
{
	int fd = ((int *) d)[0];
	int offset = ((int *) d)[1];

	if (!fs_file_descriptions[fd].inode) {
		pr_err("fd %d is not open\n", fd);
		return 0;
	}

	struct fs_inode f;
	read_block(fs_file_descriptions[fd].inode, (void *) &f);

	if (offset > f.size) {
		pr_err("offset is larger than file (%d > %d)\n", offset, f.size);
		return 0;
	}

	pr("Moving rw_offset of fd %d: %d -> %d\n",
			fd, fs_file_descriptions[fd].rw_offset, offset);
	fs_file_descriptions[fd].rw_offset = offset;

	return 0;
}

static void read_fd_block(unsigned int fd, unsigned int block_index, unsigned char *buf)
{
	struct fs_inode f;
	read_block(fs_file_descriptions[fd].inode, (void *) &f);

	if (block_index < BLOCK_ADDRESSES_PER_INODE) {
		if (f.blocks[block_index])
			read_block(f.blocks[block_index], (void *) buf);
		else
			memset(buf, 0, FS_BLOCK_SIZE);
	} else {
		/*
		 * TODO: rewrite this potentially broken abomination normally
		 *       it has not caused issues so far, but you can never be too sure
		 */

		int ext_no = (block_index - BLOCK_ADDRESSES_PER_INODE) / BLOCK_ADDRESSES_PER_INODE_EXTENSION;
		int ext_offset = (block_index - BLOCK_ADDRESSES_PER_INODE) % BLOCK_ADDRESSES_PER_INODE_EXTENSION;

		unsigned int target_extension_address;
		unsigned int i;

		// seek to target extension address
		for (
			target_extension_address = f.next_extension, i = 0;
			(i < ext_no) && target_extension_address;
			i++
		) {
			struct fs_inode_extension ext;
			read_block(target_extension_address, (void *) &ext);
			target_extension_address = ext.next_extension;
		}

		if (!target_extension_address) {
			memset(buf, 0, FS_BLOCK_SIZE);
		} else {
			struct fs_inode_extension ext;
			read_block(target_extension_address, (void *) &ext);

			if (!ext.blocks[ext_offset])
				memset(buf, 0, FS_BLOCK_SIZE);
			else
				read_block(ext.blocks[ext_offset], (void *) buf);
		}
	}
}

static int write_fd_block(unsigned int fd, unsigned int block_index, unsigned char *buf)
{
	struct fs_inode f;
	read_block(fs_file_descriptions[fd].inode, (void *) &f);

	if (block_index < BLOCK_ADDRESSES_PER_INODE) {
		if (!f.blocks[block_index]) {
			int new_block = find_free_block();
			if (!new_block) {
				pr_err("failed to write to fd=%d block=%d: can't allocate block for writing file data\n",
						fd, block_index);
				return -1;
			}
			mark_used(new_block);

			f.blocks[block_index] = new_block;
			write_block(fs_file_descriptions[fd].inode, (void *) &f);
		}

		return write_block(f.blocks[block_index], (void *) buf);
	} else {
		int ext_no = (block_index - BLOCK_ADDRESSES_PER_INODE) / BLOCK_ADDRESSES_PER_INODE_EXTENSION;
		int ext_offset = (block_index - BLOCK_ADDRESSES_PER_INODE) % BLOCK_ADDRESSES_PER_INODE_EXTENSION;

		// treat switch from base inode to inode extension as special case
		if (!f.next_extension) {
			int new_block = find_free_block();
			if (!new_block) {
				pr_err("failed to write to fd=%d block=%d: can't allocate block for inode extension\n",
						fd, block_index);
				return -1;
			}
			mark_used(new_block);

			struct fs_inode_extension ext;
			memset(&ext, 0, sizeof(struct fs_inode_extension));
			write_block(new_block, (void *) &ext);

			f.next_extension = new_block;
			write_block(fs_file_descriptions[fd].inode, (void *) &f);
		}

		unsigned int next_ext = f.next_extension;
		unsigned int curr_ext = 0;

		struct fs_inode_extension ext;

		// seek to target extension address
		for (unsigned int i = 0; i < ext_no + 1; i++) {
			if (!next_ext) {
				int new_block = find_free_block();
				if (!new_block) {
					pr_err("failed to write to fd=%d block=%d: can't allocate block for inode extension\n",
							fd, block_index);
					return -1;
				}
				mark_used(new_block);

				ext.next_extension = new_block;
				write_block(curr_ext, (void *) &ext);

				struct fs_inode_extension new_ext;
				memset(&new_ext, 0, sizeof(struct fs_inode_extension));
				write_block(new_block, (void *) &new_ext);

				next_ext = new_block;
			}

			curr_ext = next_ext;
			read_block(curr_ext, (void *) &ext);
			next_ext = ext.next_extension;
		}

		if (!ext.blocks[ext_offset]) {
			int new_data_block = find_free_block();
			if (!new_data_block) {
				pr_err("failed to write to fd=%d block=%d: can't allocate block for data\n",
						fd, block_index);
				return -1;
			}
			mark_used(new_data_block);

			ext.blocks[ext_offset] = new_data_block;
			write_block(curr_ext, (void *) &ext);
		}

		return write_block(ext.blocks[ext_offset], (void *) buf);
	}
}

int fs_read(void *d)
{
	int fd = ((int *) d)[0];
	int amount = ((int *) d)[1];

	if (!fs_file_descriptions[fd].inode) {
		pr_err("fd %d is not open\n", fd);
		return 0;
	}

	if (amount <= 0)
		return 0;

	struct fs_inode f;
	read_block(fs_file_descriptions[fd].inode, (void *) &f);

	if (fs_file_descriptions[fd].rw_offset + amount > f.size) {
		pr_err("can not read outside of a file (offset %d + amount %d > f.size %d)\n",
				fs_file_descriptions[fd].rw_offset, amount, f.size);
		return 0;
	}

	pr("Reading %d bytes from fd %d (offset %d)\n",
			amount, fd, fs_file_descriptions[fd].rw_offset);

	unsigned char *read_data = malloc(amount);
	unsigned int total_read_data_amount = 0;

	// read from first block
	unsigned char block_buffer[FS_BLOCK_SIZE];

	int block_index = fs_file_descriptions[fd].rw_offset / FS_BLOCK_SIZE;
	int block_offset = fs_file_descriptions[fd].rw_offset % FS_BLOCK_SIZE;

	read_fd_block(fd, block_index, block_buffer);

	if (block_offset + amount <= FS_BLOCK_SIZE) {
		memcpy(read_data, &(block_buffer[block_offset]), amount);
		goto print_read_data;
	} else {
		memcpy(read_data, &(block_buffer[block_offset]), FS_BLOCK_SIZE - block_offset);
		total_read_data_amount += FS_BLOCK_SIZE - block_offset;
	}

	// read from all next blocks
	while (amount - total_read_data_amount > 0) {
		block_index++;
		read_fd_block(fd, block_index, block_buffer);
		int bytes_to_read = (amount - total_read_data_amount > FS_BLOCK_SIZE)
			? FS_BLOCK_SIZE : amount - total_read_data_amount;

		memcpy(&(read_data[total_read_data_amount]), block_buffer, bytes_to_read);
		total_read_data_amount += bytes_to_read;
	}

print_read_data:
	pr("Updating fd %d offset: %d -> %d\n",
			fd, fs_file_descriptions[fd].rw_offset, fs_file_descriptions[fd].rw_offset+amount);
	fs_file_descriptions[fd].rw_offset += amount;

	write_stdout(read_data, amount);
	pr_stdout("\n");

	free(read_data);

	return 0;
}

int fs_write(void *d)
{
	int fd = ((int *) d)[0];
	char *str = *((char **) ((char *) d+4));
	int str_len = strlen(str);

	if (!fs_file_descriptions[fd].inode) {
		pr_err("fd %d is not open\n", fd);
		return 0;
	}

	if (str_len == 0)
		return 0;

	int block_index = fs_file_descriptions[fd].rw_offset / FS_BLOCK_SIZE;
	int block_offset = fs_file_descriptions[fd].rw_offset % FS_BLOCK_SIZE;

	unsigned int total_bytes_written = 0;

	unsigned char data_buffer[FS_BLOCK_SIZE];

	// first block
	read_fd_block(fd, block_index, data_buffer);
	{
		unsigned int copy_amount = ((FS_BLOCK_SIZE - block_offset) <= str_len)
			? FS_BLOCK_SIZE - block_offset
			: str_len;
		memcpy(&(data_buffer[block_offset]), str, copy_amount);
		total_bytes_written += copy_amount;
	}
	write_fd_block(fd, block_index, data_buffer);
	block_index++;

	// full middle blocks
	for ( ; str_len - total_bytes_written >= FS_BLOCK_SIZE; block_index++) {
		write_fd_block(fd, block_index, (unsigned char *) &(str[total_bytes_written]));
		total_bytes_written += FS_BLOCK_SIZE;
	}

	// last partial block
	if (str_len - total_bytes_written) {
		read_fd_block(fd, block_index, data_buffer);
		memcpy(data_buffer, &(str[total_bytes_written]), str_len - total_bytes_written);
		write_fd_block(fd, block_index, data_buffer);

		total_bytes_written += (str_len - total_bytes_written);
	}

	pr("Moving fd %d offset: %d -> %d\n",
			fd, fs_file_descriptions[fd].rw_offset, fs_file_descriptions[fd].rw_offset + total_bytes_written);
	fs_file_descriptions[fd].rw_offset += total_bytes_written;

	struct fs_inode f;
	read_block(fs_file_descriptions[fd].inode, (void *) &f);

	if (fs_file_descriptions[fd].rw_offset > f.size) {
		pr("Increasing fd %d file size: %d -> %d\n",
				fd, f.size, fs_file_descriptions[fd].rw_offset);
		f.size = fs_file_descriptions[fd].rw_offset;
		write_block(fs_file_descriptions[fd].inode, (void *) &f);
	}

	return 0;
}

int fs_truncate(void *d)
{
	char *path = *((char **) d);
	int size = *((int *) ((char **) d+1));

	if (size < 0) {
		pr_err("file size can not be negative\n");
		return 0;
	}

	struct resolved_path rp;
	resolve_path(&rp, path, FOLLOW_LAST_SYMLINK);

	if (rp.target_inode_ptr < 0) {
		pr_err("no such file: '%s'\n", path);
		return 0;
	}

	struct fs_inode inode;
	read_block(read_inode_ptr(rp.target_inode_ptr), &inode);

	if (size > inode.size) {
		pr("Increasing file size of '%s': %d -> %d\n", rp.target_fname, inode.size, size);
		inode.size = size;
		write_block(read_inode_ptr(rp.target_inode_ptr), &inode);
	} else {
		pr("Decreasing file size of '%s': %d -> %d\n", rp.target_fname, inode.size, size);
		inode.size = size;

		// cleanup
		int new_block_amount = inode.size / FS_BLOCK_SIZE;
		if (inode.size % FS_BLOCK_SIZE)
			new_block_amount++;

		int blocks_seen = 0;

		// look through base inode blocks
		for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE; i++, blocks_seen++) {
			if ((blocks_seen >= new_block_amount) && (inode.blocks[i])) {
				mark_free(inode.blocks[i]);
				inode.blocks[i] = 0;
			}
		}
		write_block(read_inode_ptr(rp.target_inode_ptr), &inode);

		// look through inode extension blocks
		struct fs_inode_extension ext;
		unsigned int next_ext = inode.next_extension;
		unsigned int curr_ext;

		while (next_ext) {
			read_block(next_ext, &ext);

			for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE_EXTENSION; i++, blocks_seen++) {
				if ((blocks_seen >= new_block_amount) && (ext.blocks[i])) {
					mark_free(ext.blocks[i]);
					ext.blocks[i] = 0;
				}
			}

			write_block(next_ext, &ext);
			next_ext = ext.next_extension;
		}

		// look through inode extensions themselves
		int required_blocks_after_base_inode = (int) inode.size - (int) BLOCK_ADDRESSES_PER_INODE;
		int required_extensions = required_blocks_after_base_inode >= 0
			? required_blocks_after_base_inode / BLOCK_ADDRESSES_PER_INODE_EXTENSION
			: 0;

		if ((inode.size - BLOCK_ADDRESSES_PER_INODE) % BLOCK_ADDRESSES_PER_INODE_EXTENSION)
			required_extensions++;

		next_ext = inode.next_extension;

		if (!required_extensions) {
			// zero base inode next_extension ptr
			inode.next_extension = 0;
			write_block(read_inode_ptr(rp.target_inode_ptr), &inode);
		} else {
			// seek to last required extension
			for (int i = 0; i < required_extensions; i++) {
				if (!next_ext)
					return 0;

				curr_ext = next_ext;
				read_block(curr_ext, &ext);
				next_ext = ext.next_extension;
			}

			// remove next_extension ptr
			ext.next_extension = 0;
			write_block(curr_ext, &ext);
		}

		// erase all remaining extensions
		while (next_ext) {
			mark_free(next_ext);
			read_block(next_ext, &ext);
			next_ext = ext.next_extension;
		}
	}

	return 0;
}

int fs_close(void *d)
{
	int fd = *((int *) d);

	// remove inode number from fd
	if (!fs_file_descriptions[fd].inode) {
		pr_err("fd %d is not open\n", fd);
		return 0;
	}

	unsigned int inode_location_cache = fs_file_descriptions[fd].inode;

	fs_file_descriptions[fd].inode = 0;
	pr("fd %d closed\n", fd);

	if (inode_is_referenced(inode_location_cache))
		return 0;

	pr("No open fd reference inode %d, cleaning up\n", inode_location_cache);

	clean_inode(inode_location_cache);

	return 0;
}


int fs_create(void *d)
{
	if (!write_permitted) {
		pr_err("write operations are prohibited\n");
		return 0;
	}

	char *path = *((char **) d);
	{
		int path_len = strlen(path);
		if (path_len > FS_MAX_PATH_LEN) {
			pr_err("path too long (%d > %d)\n",
					path_len, FS_MAX_PATH_LEN);
			return 0;
		}
	}

	struct resolved_path rp;
	resolve_path(&rp, path, 0);

	if (rp.parent_inode_ptr < 0) {
		pr_err("unable to create file: no such directory: '%s'\n", path);
		return 0;
	}

	if (rp.target_inode_ptr >= 0) {
		pr_err("file already exists: '%s'\n", rp.target_fname);
		return 0;
	}

	char fname[FS_MAX_FNAME_LEN+1];
	extract_basename(path, fname);

	pr("Creating regular file '%s'\n", fname);

	int inode_block_no = find_free_block();
	if (!inode_block_no) {
		pr_err("no free blocks available to save file inode\n");
		return 0;
	}

	// write new file inode
	struct fs_inode newf = {0};
	newf.ftype = REGULAR;
	newf.ref_count = 1;
	newf.size = 0;

	{
		int bytes_written = write_block(inode_block_no, (void *) &newf);

		if (bytes_written < 0) {
			pr_err("failed to write inode block to device '%s'\n", used_file_path);
			return 0;
		} else if (bytes_written < FS_BLOCK_SIZE) {
			pr_err("failed to write full inode block to device '%s' (written %d/%d bytes)\n",
					used_file_path, bytes_written, FS_BLOCK_SIZE);
			return 0;
		} else {
			pr("Written inode block to device '%s'\n", used_file_path);
		}

		mark_used(inode_block_no);
	}

	// allocate and write inode pointer for new inode
	unsigned int inode_ptr_index = find_free_inode_ptr();
	if (!inode_ptr_index) {
		pr_err("no free inode ptr found\n");
		return 0;
	}
	write_inode_ptr(inode_ptr_index, inode_block_no);

	// add filename to current directory inode
	fs_add_fname_to_directory(rp.parent_inode_ptr, inode_ptr_index, fname);

	return 0;
}

int fs_ln(void *d)
{
	char *prev_path = ((char **) d)[0];
	char *new_path = ((char **)d)[1];

	char new_fname[FS_MAX_FNAME_LEN+1];
	{
		int new_fname_len = extract_basename(new_path, new_fname);
		if (new_fname_len > FS_MAX_FNAME_LEN) {
			pr_err("new filename too long (%d > %d)\n", new_fname_len, FS_MAX_FNAME_LEN);
			return 0;
		}
	}

	struct resolved_path prev_rp, new_rp;

	resolve_path(&prev_rp, prev_path, 0);
	if (prev_rp.target_inode_ptr < 0) {
		pr_err("no such file: '%s'\n", prev_path);
		return 0;
	}

	{
		struct fs_inode prev_i;
		read_block(read_inode_ptr(prev_rp.target_inode_ptr), &prev_i);

		if (prev_i.ftype == DIRECTORY) {
			pr_err("refusing to create hard link for directory\n");
			return 0;
		}
	}

	resolve_path(&new_rp, new_path, 1);
	if (new_rp.parent_inode_ptr < 0) {
		pr_err("failed to create hard link: no such directory: '%s'\n", new_path);
		return 0;
	} else if (new_rp.target_inode_ptr >= 0) {
		pr_err("file already exists: '%s'\n", new_rp.target_fname);
		return 0;
	}

	pr("Making hard link '%s' -> '%s'\n", new_path, prev_path);

	if (fs_add_fname_to_directory(new_rp.parent_inode_ptr, prev_rp.target_inode_ptr, new_fname) < 0) {
		pr_err("failed to add filename to directory '%s' (inode_ptr=%d)\n",
				new_rp.parent_fname, new_rp.parent_inode_ptr);
		return 0;
	} else {
		pr("Added new filename to directory '%s' (inode_ptr=%d)\n",
				new_rp.parent_fname, new_rp.parent_inode_ptr);
	}

	// update ref_count in file inode
	struct fs_inode i;
	read_block(read_inode_ptr(prev_rp.target_inode_ptr), &i);
	i.ref_count++;
	write_block(read_inode_ptr(prev_rp.target_inode_ptr), &i);

	pr("Updated inode ref_count (%d -> %d)\n", i.ref_count-1, i.ref_count);

	return 0;
}


static int last_significant_slash_position(char *path, int path_len)
{
	int last_position = -1;

	for (int i = 0; i < path_len; i++)
		if ((path[i] == '/') && (i+1 != path_len))
			last_position = i;

	return last_position;
}

static int extract_basename(char *path, char *name)
{
	int path_len = strlen(path);

	int lsp = last_significant_slash_position(path, path_len);
	int fname_len = path_len - lsp - 1;

	if (fname_len > FS_MAX_FNAME_LEN) {
		pr_err("filename too long (%d > %d)",
				fname_len, FS_MAX_FNAME_LEN);
		return -1;
	}

	// allow the usage of NULL ptr to discard basename string
	if (name)
		strcpy(name, &(path[lsp+1]));

	return fname_len;
}

int fs_mkdir(void *d)
{
	char *dirpath = *((char **)d);
	int dirpath_len = strlen(dirpath);

	if (dirpath_len > FS_MAX_PATH_LEN) {
		pr_err("path too long ('%s', %d > %d)\n",
				dirpath, dirpath_len, FS_MAX_FNAME_LEN);
		return 0;
	}

	char dirname[FS_MAX_FNAME_LEN+1];
	{
		int res = extract_basename(dirpath, dirname);
		if (res < 0) {
			pr_err("failed to extract dirname from path '%s'\n",
					dirpath);
			return 0;
		}
	}
	int dirname_len = strlen(dirname);

	if (dirname_len > FS_MAX_FNAME_LEN) {
		pr_err("directory name too long ('%s', %d > %d)\n",
				dirname, dirname_len, FS_MAX_FNAME_LEN);
		return 0;
	}

	struct resolved_path rp;
	resolve_path(&rp, dirpath, 0);
	if (rp.parent_inode_ptr < 0) {
		pr_err("failed to find parent of '%s'\n", dirpath);
		return 0;
	} else if (rp.target_inode_ptr >= 0) {
		pr_err("fname '%s' already exists in directory '%s'\n",
				rp.target_fname, rp.parent_fname);
		return 0;
	}

	int target_inode_ptr = find_free_inode_ptr();
	if (!target_inode_ptr) {
		pr_err("no free inode ptr\n");
		return 0;
	}

	int target_inode_block = find_free_block();
	if (!target_inode_block) {
		pr_err("no space left on device\n");
		return 0;
	}

	struct fs_inode dir;
	memset(&dir, 0, sizeof(dir));

	dir.ftype = DIRECTORY;
	dir.ref_count = 1;

	write_block(target_inode_block, &dir);
	mark_used(target_inode_block);

	write_inode_ptr(target_inode_ptr, target_inode_block);

	if (fs_add_fname_to_directory(rp.parent_inode_ptr, target_inode_ptr, dirname) < 0) {
		pr_err("failed to add record '%s' -> inode_ptr=%d to directory '%s' (inode_ptr=%d)\n",
				dirname, target_inode_ptr, rp.parent_fname, rp.parent_inode_ptr);
		return 0;
	}

	// add . and ..
	fs_add_fname_to_directory(target_inode_ptr, target_inode_ptr, ".");
	fs_add_fname_to_directory(target_inode_ptr, rp.parent_inode_ptr, "..");

	return 0;
}


static int count_active_directory_records(struct fs_inode *inode)
{
	int total_active_records = 0;

	// base inode
	for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE; i++) {
		if (!inode->blocks[i])
			continue;

		struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];
		read_block(inode->blocks[i], &recs);

		for (int j = 0; j < DIRECTORY_RECORDS_PER_BLOCK; j++) {
			if (!recs[j].fname[0])
				continue;

			if (!strcmp(recs[j].fname, "."))
				continue;

			if (!strcmp(recs[j].fname, ".."))
				continue;

			total_active_records++;
		}
	}

	// inode extensions
	unsigned int next_ext = inode->next_extension;

	struct fs_inode_extension ext;

	while (next_ext) {
		read_block(next_ext, &ext);
		next_ext = ext.next_extension;

		for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE_EXTENSION; i++) {
			if (!ext.blocks[i])
				continue;

			struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];
			read_block(ext.blocks[i], &recs);

			for (int j = 0; j < DIRECTORY_RECORDS_PER_BLOCK; j++) {
				if (!recs[j].fname[0])
					continue;

				if (!strcmp(recs[j].fname, "."))
					continue;

				if (!strcmp(recs[j].fname, ".."))
					continue;

				total_active_records++;
			}
		}
	}

	return total_active_records;
}

int fs_rmdir(void *d)
{
	char *dirpath = *((char **)d);
	int dirpath_len = strlen(dirpath);

	if (dirpath_len > FS_MAX_PATH_LEN) {
		pr_err("path too long ('%s', %d > %d)\n",
				dirpath, dirpath_len, FS_MAX_FNAME_LEN);
		return 0;
	}

	struct resolved_path rp;
	resolve_path(&rp, dirpath, 0);

	if (rp.parent_inode_ptr < 0) {
		pr_err("failed to find parent directory of '%s'\n", dirpath);
		return 0;
	} else if (rp.target_inode_ptr < 0) {
		pr_err("no such file: '%s'\n", dirpath);
		return 0;
	} else if (!strcmp(rp.target_fname, ".")) {
		pr_err("can not remove '.' from a directory\n");
		return 0;
	}

	{
		struct fs_inode i;
		read_block(read_inode_ptr(rp.target_inode_ptr), &i);

		if (i.ftype != DIRECTORY) {
			pr_err("'%s' is not a directory\n", rp.target_fname);
			return 0;
		}

		if (count_active_directory_records(&i)) {
			pr_err("directory '%s' is not empty\n", rp.target_fname);
			return 0;
		}
	}

	fs_remove_fname_from_directory(rp.parent_inode_ptr, rp.target_fname);

	return 0;
}


static int get_fname_by_inode_ptr(int dir_inode_ptr, int file_inode_ptr, char *name)
{
	struct fs_inode dir;
	read_block(read_inode_ptr(dir_inode_ptr), &dir);

	// search base inode
	for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE; i++) {
		struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];

		if (!dir.blocks[i])
			continue;

		read_block(dir.blocks[i], &recs);

		for (int j = 0; j < DIRECTORY_RECORDS_PER_BLOCK; j++) {
			if (!recs[j].fname[0])
				continue;

			if (recs[j].inode_no != file_inode_ptr)
				continue;

			strcpy(name, recs[j].fname);
			return 0;
		}
	}

	// search inode extensions
	unsigned int next_ext = dir.next_extension;

	struct fs_inode_extension ext;

	while (next_ext) {
		read_block(next_ext, &ext);
		next_ext = ext.next_extension;

		for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE_EXTENSION; i++) {
			struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];

			if (!ext.blocks[i])
				continue;

			read_block(ext.blocks[i], &recs);

			for (int j = 0; j < DIRECTORY_RECORDS_PER_BLOCK; j++) {
				if (!recs[j].fname[0])
					continue;

				if (recs[j].inode_no != file_inode_ptr)
					continue;

				strcpy(name, recs[j].fname);
				return 0;
			}
		}
	}

	pr_err("no such file (inode_ptr=%d)\n", file_inode_ptr);
	return -1;
}

static int build_canonical_dir_path(char *path, int dir_inode_ptr)
{
	// build directory inode_ptr-based reverse path
	int dir_inode_ptrs[FS_MAX_DIRECTORY_DEPTH];
	int dir_inode_ptrs_len = 1;

	dir_inode_ptrs[0] = dir_inode_ptr;

	for ( ; dir_inode_ptrs_len < FS_MAX_DIRECTORY_DEPTH; dir_inode_ptrs_len++) {
		// check if reached the root dir
		if (!dir_inode_ptrs[dir_inode_ptrs_len-1])
			break;

		int *r = find_filename_in_directory(dir_inode_ptrs[dir_inode_ptrs_len-1], "..");

		if (!r) {
			pr_err("failed to find parent directory of inode_ptr=%d\n", dir_inode_ptrs[dir_inode_ptrs_len-1]);
			return -1;
		}

		dir_inode_ptrs[dir_inode_ptrs_len] = r[2];
		free(r);
	}

	// build string path based on inode_ptr list
	memset(path, 0, sizeof(FS_MAX_PATH_LEN));

	for (int i = dir_inode_ptrs_len - 2; i >= 0; i--) {
		char fname[FS_MAX_FNAME_LEN+1];

		if (get_fname_by_inode_ptr(dir_inode_ptrs[i+1], dir_inode_ptrs[i], fname) < 0) {
			pr_err("failed to build canonical path\n");
			return -1;
		}

		strcat(path, "/");
		strcat(path, fname);
	}

	return 0;
}

int fs_cd(void *d)
{
	char *new_dir = *((char **)d);
	int new_dir_len = strlen(new_dir);

	if (new_dir_len > FS_MAX_PATH_LEN) {
		pr_err("path too long (%d > %d)\n", new_dir_len, FS_MAX_PATH_LEN);
		return 0;
	}

	struct resolved_path rp;
	resolve_path(&rp, new_dir, FOLLOW_LAST_SYMLINK);

	if (rp.parent_inode_ptr < 0) {
		pr_err("failed to find parent of '%s' from '%s'\n", new_dir, fs_cwd);
		return 0;
	}

	if (rp.target_inode_ptr < 0) {
		pr_err("no such directory: '%s'\n", new_dir);
		return 0;
	}

	char canonical_path[FS_MAX_PATH_LEN+1];
	if (build_canonical_dir_path(canonical_path, rp.target_inode_ptr) < 0) {
		pr_err("failed to build canonical path to '%s' (inode_ptr=%d)\n",
				new_dir, rp.target_inode_ptr);
		return 0;
	}

	if (!canonical_path[0])
		canonical_path[0] = '/';

	char *cpp = (char *) canonical_path;
	fs_chdir(&cpp);
	fs_cwd_inode_ptr = rp.target_inode_ptr;

	return 0;
}


int fs_rm(void *d)
{
	if (!write_permitted) {
		pr_err("device '%s' is write-protected\n", used_file_path);
		return 0;
	}

	char *path = *((char **) d);
	{
		int path_len = strlen(path);
		if (path_len > FS_MAX_PATH_LEN) {
			pr_err("path too long (%d > %d)\n",
					path_len, FS_MAX_PATH_LEN);
			return 0;
		}
	}

	struct resolved_path rp;
	resolve_path(&rp, path, 0);

	if (rp.target_inode_ptr < 0) {
		pr_err("file does not exist: '%s'\n", path);
		return 0;
	}

	struct fs_inode i;
	read_block(read_inode_ptr(rp.target_inode_ptr), &i);

	if (i.ftype == DIRECTORY) {
		pr_err("file '%s' is a directory\n", rp.target_fname);
		return 0;
	}

	if (fs_remove_fname_from_directory(rp.parent_inode_ptr, rp.target_fname) < 0) {
		pr_err("failed to unlink '%s'\n", rp.target_fname);
	} else {
		pr("Unlinked '%s'\n", rp.target_fname);
	}

	return 0;
}

int fs_ls(void *d)
{
	if (used_file_fd <= 0) {
		pr_err("no storage device\n");
		return 0;
	}

	int dir_inode = read_inode_ptr(fs_cwd_inode_ptr);

	struct fs_inode dir;
	read_block(dir_inode, (void *) &dir);

	// list entries from base inode
	for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE; i++) {
		if (!dir.blocks[i])
			continue;

		struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];
		read_block(dir.blocks[i], (void *) &recs);

		for (int k = 0; k < DIRECTORY_RECORDS_PER_BLOCK; k++) {
			if (!recs[k].fname[0])
				continue;

			pr_stdout("%s -> inode_ptr=%d\n", recs[k].fname, recs[k].inode_no);
		}
	}

	// list entries from inode extension
	struct fs_inode_extension ext;
	unsigned int next_ext = dir.next_extension;

	while (next_ext) {
		read_block(next_ext, (void *) &ext);
		next_ext = ext.next_extension;

		for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE_EXTENSION; i++) {
			if (!ext.blocks[i])
				continue;

			struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];
			read_block(ext.blocks[i], (void *) &recs);

			for (int k = 0; k < DIRECTORY_RECORDS_PER_BLOCK; k++) {
				if (!recs[k].fname[0])
					continue;

				pr_stdout("%s -> inode_ptr=%d\n", recs[k].fname, recs[k].inode_no);
			}
		}
	}


	return 0;
}

int fs_la(void *d)
{
	if (used_file_fd <= 0) {
		pr_err("no storage device\n");
		return 0;
	}

	int dir_inode = read_inode_ptr(fs_cwd_inode_ptr);

	struct fs_inode dir;
	read_block(dir_inode, (void *) &dir);

	pr_stdout("directory size: %d\n", dir.size);

	// list entries from base inode
	for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE; i++) {
		if (!dir.blocks[i])
			continue;

		struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];
		read_block(dir.blocks[i], (void *) &recs);

		for (int k = 0; k < DIRECTORY_RECORDS_PER_BLOCK; k++) {
			if (!recs[k].fname[0])
				continue;

			struct fs_inode f_inode;
			read_block(read_inode_ptr(recs[k].inode_no), (void *) &f_inode);

			if (f_inode.ftype == DIRECTORY) {
				pr_stdout(COLOR_BLUE "%s" COLOR_RESET
						" (inode_ptr=%d -> inode=%d, ref_count=%d, size=%d, type=dir)\n",
						recs[k].fname, recs[k].inode_no, read_inode_ptr(recs[k].inode_no),
						f_inode.ref_count, f_inode.size);
			} else {
				pr_stdout("%s (inode_ptr=%d -> inode=%d, ref_count=%d, size=%d, type=reg)\n",
						recs[k].fname, recs[k].inode_no, read_inode_ptr(recs[k].inode_no),
						f_inode.ref_count, f_inode.size);
			}
		}
	}

	// list entries from inode extension
	struct fs_inode_extension ext;
	unsigned int next_ext = dir.next_extension;

	while (next_ext) {
		read_block(next_ext, (void *) &ext);
		next_ext = ext.next_extension;

		for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE_EXTENSION; i++) {
			if (!ext.blocks[i])
				continue;

			struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];
			read_block(ext.blocks[i], (void *) &recs);

			for (int k = 0; k < DIRECTORY_RECORDS_PER_BLOCK; k++) {
				if (!recs[k].fname[0])
					continue;

				struct fs_inode f_inode;
				read_block(read_inode_ptr(recs[k].inode_no), (void *) &f_inode);

				if (f_inode.ftype == DIRECTORY) {
					pr_stdout(COLOR_BLUE "%s" COLOR_RESET
							" (inode_ptr=%d -> inode=%d, ref_count=%d, size=%d, type=dir)\n",
							recs[k].fname, recs[k].inode_no, read_inode_ptr(recs[k].inode_no),
							f_inode.ref_count, f_inode.size);
				} else {
					pr_stdout("%s (inode_ptr=%d -> inode=%d, ref_count=%d, size=%d, type=reg)\n",
							recs[k].fname, recs[k].inode_no, read_inode_ptr(recs[k].inode_no),
							f_inode.ref_count, f_inode.size);
				}
			}
		}
	}

	return 0;
}

int fs_stat(void *d)
{
	char *path = *((char **) d);

	struct resolved_path rp;
	resolve_path(&rp, path, 0);

	if (rp.target_inode_ptr < 0) {
		pr_err("no such file: '%s'\n", path);
		return 0;
	}

	struct fs_inode i;
	read_block(read_inode_ptr(rp.target_inode_ptr), &i);

	if (i.ftype == DIRECTORY) {
		pr_stdout("inode_ptr=%d -> inode=%d\nref_count=%d\nsize=%d\ntype=dir\n",
				rp.target_inode_ptr, read_inode_ptr(rp.target_inode_ptr), i.ref_count, i.size);
	} else {
		pr_stdout("inode_ptr=%d -> inode=%d\nref_count=%d\nsize=%d\ntype=reg\n",
				rp.target_inode_ptr, read_inode_ptr(rp.target_inode_ptr), i.ref_count, i.size);
	}

	return 0;
}

int fs_use(void *d)
{
	char *fname = *((char **) d);
	int name_len = strlen(fname);

	if (name_len > FS_MAX_DEVICE_FILE_NAME_LEN) {
		pr_err("device filename too long (> %d)\n", FS_MAX_DEVICE_FILE_NAME_LEN);
		return 0;
	}

	pr("Using file '%s' as storage device\n", fname);

	strcpy(used_file_path, fname);

	if (used_file_fd > 0)
		close(used_file_fd);

	used_file_fd = open(fname, O_RDWR);

	if (used_file_fd < 0) {
		pr_err("failed to open filename '%s'\n", fname);
		return 0;
	}

	int fs_version = identify_fs();
	if (!fs_version) {
		pr_info("filesystem could not be identified on device '%s'\n", fname);
		write_permitted = 0;
	} else if (fs_version != 1) {
		pr_warn("filesystem is corrupted or has unsupported version (0x%hhx)\n", fs_version);
		write_permitted = 0;
	} else if (fs_version == 1) {
		pr_info("filesystem v1 has been identified on device '%s'\n", fname);
		write_permitted = 1;
	}

	if (write_permitted) {
		memset(fs_cwd, 0, sizeof(fs_cwd));
		char *root_dir_path = "/";
		fs_chdir((void *) &root_dir_path);

		fs_cwd_inode_ptr = 0;
	}

	return 0;
}

int fs_mkfs(void *d)
{
	if (!write_permitted) {
		pr_err("device '%s' is write-protected\n", used_file_path);
		return 0;
	}

	if (used_file_fd <= 0) {
		pr_err("storage device not present\n");
		return 0;
	}

	int max_inode_count = *((int *)d);

	if (max_inode_count <= 0) {
		pr_err("max inode count must be positive (got %d)\n", max_inode_count);
		return 0;
	}

	struct stat st;
	if (fstat(used_file_fd, &st) < 0) {
		pr_err("could not stat device '%s'\n", used_file_path);
		return 0;
	}

	int block_count = st.st_size / FS_BLOCK_SIZE;
	int blocks_used_for_bitmap = block_count / (FS_BLOCK_SIZE * 8);
	if (block_count % (FS_BLOCK_SIZE * 8))
		blocks_used_for_bitmap++;

	if (blocks_used_for_bitmap > FS_MAX_BITMAP_SIZE) {
		pr_err("memory bitmap is too large (%d blocks > %d)\n", blocks_used_for_bitmap, FS_MAX_BITMAP_SIZE);
		return 0;
	}

	pr("Formatting storage device '%s' of size %ld (total_block_count = %d, bitmap_blocks = %d) with %d allowed inode pointers\n", used_file_path, st.st_size, block_count, blocks_used_for_bitmap, max_inode_count);

	struct fs_header fsh = {0};
	fsh.version = 0x1;
	fsh.max_inode_count = max_inode_count;
	fsh.block_count = block_count;

	pr("header size is %ld bytes, writing it to the first block\n", sizeof(fsh));

	int result = write_block(0, (void *) &fsh);
	if (FS_BLOCK_SIZE != result) {
		if (result < 0) {
			pr_err("failed to write fs header to device '%s'\n", used_file_path);
		} else {
			pr_err("failed to write full block to device, written %d/%d bytes\n", result, FS_BLOCK_SIZE);
		}

		return 0;
	}

	int blocks_used = 1 + blocks_used_for_bitmap;

	unsigned char bitmap_block[FS_BLOCK_SIZE];
	unsigned int j = 0;

	for (int i = 0; i < blocks_used_for_bitmap; i++) {
		memset(bitmap_block, 0, FS_BLOCK_SIZE);
		for (int k = 0; k < FS_BLOCK_SIZE; k++) {
			for (int t = 0; t < 8; t++, j++) {
				if (j == blocks_used)
					goto finish_current_block;

				bitmap_block[i] |= (1 << t);
			}
		}

finish_current_block:
		{
			int bytes_written = write_block(i+1, (void *) bitmap_block);

			if (bytes_written < 0) {
				pr_err("failed to write bitmap block %d/%d on device '%s'\n",
						i+1, blocks_used_for_bitmap, used_file_path);
				return 0;
			} else if (bytes_written < FS_BLOCK_SIZE) {
				pr_err("failed to write full bitmap block %d/%d on device '%s' (written %d/%d bytes)\n",
						i+1, blocks_used_for_bitmap, used_file_path, bytes_written, FS_BLOCK_SIZE);
				return 0;
			} else {
				pr("Written bitmap block %d/%d on device '%s'\n", i+1, blocks_used_for_bitmap, used_file_path);
			}
		}
	}


	// create root directory automatically

	struct fs_inode root_dir = {0};
	root_dir.ftype = DIRECTORY;
	root_dir.ref_count = 1;

	unsigned int free_block_index = find_free_block();

	if (!free_block_index) {
		pr_err("failed to find free block for root directory\n");
		return 0;
	}

	{
		int bytes_written = write_block(free_block_index, (void *) &root_dir);
		if (bytes_written < 0) {
			pr_err("failed to write root directory block on device '%s'\n", used_file_path);
			return 0;
		} else if (bytes_written < FS_BLOCK_SIZE) {
			pr_err("failed to write full root directory block on device '%s' (written %d/%d bytes)\n",
					used_file_path, bytes_written, FS_BLOCK_SIZE);
			return 0;
		} else {
			pr("Written root directory block on device '%s'\n", used_file_path);
		}
	}
	mark_used(free_block_index);

	// inode0 -> root_dir_block
	write_inode_ptr(0, free_block_index);

	memset(fs_cwd, 0, sizeof(fs_cwd));
	char *root_dir_path = "/";
	fs_chdir((void *) &root_dir_path);

	fs_cwd_inode_ptr = 0;

	// add . and ..
	fs_add_fname_to_directory(0, 0, ".");
	fs_add_fname_to_directory(0, 0, "..");

	return 0;
}