实验目的
本实验旨在设计和实现一个简单的文件系统，以加深对操作系统中文件管理机制的理解。通过本次实验，我们将学习如何模拟磁盘操作、位示图管理、文件描述符表和打开文件表等关键概念。
实验环境
- 操作系统：Linux
- 编译器：GCC (GNU Compiler Collection)
- 开发工具：Vim/VSCode
实验内容
文件系统初始化
在程序启动时，我们需要初始化文件系统。这包括清空模拟的磁盘空间（ldisk）、位示图（bitmap）、文件描述符表（fd_table）和打开文件表（of_table）。具体代码如下：
void init_fs() {
memset(ldisk, 0, sizeof(ldisk));
memset(bitmap, 0, sizeof(bitmap));
memset(fd_table, 0, sizeof(fd_table));
for (int i = 0; i < MAX_FILES; i++) {
of_table[i].fd_index = -1;
}
printf("File system initialized.\n");
}
文件创建与删除
创建文件
当用户调用 create 命令时，我们需要找到一个可用的文件描述符索引，并分配一个初始数据块给新文件。然后，将文件名及其对应的文件描述符索引添加到目录中。相关代码如下：
int create(const char *filename) {
for (int i = 1; i < MAX_FILES; i++) { // 从索引1开始，因为0用于目录
if (fd_table[i].length == 0) {
fd_table[i].blocks[0] = find_free_block();
if (fd_table[i].blocks[0] == -1) {
printf("No free blocks available for creating file '%s'.\n", filename);
return -1;
}
bitmap[fd_table[i].blocks[0]] = 1;
add_to_directory(filename, i);
printf("Created file '%s' with fd_index %d and initial block %d.\n", filename, i, fd_table[i].blocks[0]);
return 0;
}
}
printf("Maximum number of files reached. Cannot create file '%s'.\n", filename);
return -1;
}
删除文件
当用户调用 destroy 命令时，我们需要释放文件占用的所有数据块，并将其从目录中移除。相关代码如下：
int destroy(const char *filename) {
int fd_index = find_in_directory(filename);
if (fd_index == -1) {
printf("File '%s' not found in directory.\n", filename);
return -1;
}
if (is_file_open(fd_index)) {
printf("Cannot destroy file '%s' as it is currently open.\n", filename);
return -1;
}
free_blocks(fd_index);
remove_from_directory(filename);
printf("Destroyed file '%s' with fd_index %d.\n", filename, fd_index);
return 0;
}
文件打开与关闭
打开文件
当用户调用 open 命令时，我们需要检查文件是否存在并且未被打开。如果满足条件，则将其添加到打开文件表中，并读取其第一个数据块到缓冲区。相关代码如下：
int open(const char *filename) {
int fd_index = find_in_directory(filename);
if (fd_index == -1) {
printf("File '%s' not found.\n", filename);
return -1;
}
if (is_file_open(fd_index)) {
printf("File '%s' already open.\n", filename);
return -1;
}
for (int i = 0; i < MAX_FILES; i++) {
if (of_table[i].fd_index == -1) {
of_table[i].fd_index = fd_index;
of_table[i].pointer = 0;
read_block(fd_table[fd_index].blocks[0], of_table[i].buffer);
of_count++;
printf("Open file table slot %d used for fd_index %d\n", i, fd_index);
return i;
}
}
printf("No available slots in open file table.\n");
return -1;
}
关闭文件
当用户调用 close 命令时，我们需要将文件缓冲区的内容写回磁盘，并释放打开文件表中的相应槽位。相关代码如下：
int close(int index) {
if (index >= 0 && index < MAX_FILES && of_table[index].fd_index != -1) {
write_block(fd_table[of_table[index].fd_index].blocks[0], of_table[index].buffer);
of_table[index].fd_index = -1;
of_count--;
printf("Closed file descriptor index %d\n", index);
return 0;
}
printf("Invalid file descriptor index %d.\n", index);
return -1;
}
文件读写
写入文件
当用户调用 write 命令时，我们需要将数据写入文件的当前指针位置。如果需要，我们会分配新的数据块来存储额外的数据。相关代码如下：
size_t write(int index, const char *mem_area, size_t count) {
if (index >= 0 && index < MAX_FILES && of_table[index].fd_index != -1) {
size_t bytes_written = 0;
while (bytes_written < count) {
size_t offset = of_table[index].pointer % B;
size_t block_index = of_table[index].pointer / B;
size_t remaining = B - offset;
size_t to_copy = remaining < (count - bytes_written) ? remaining : (count - bytes_written);
if (block_index < K - 1) { if (offset == 0 || fd_table[of_table[index].fd_index].blocks[block_index] == 0) { fd_table[of_table[index].fd_index].blocks[block_index] = find_free_block(); if (fd_table[of_table[index].fd_index].blocks[block_index] == -1) break; bitmap[fd_table[of_table[index].fd_index].blocks[block_index]] = 1; } read_block(fd_table[of_table[index].fd_index].blocks[block_index], of_table[index].buffer); printf("Buffer after read: %.50s...\n", of_table[index].buffer); memcpy(of_table[index].buffer + offset, mem_area + bytes_written, to_copy); bytes_written += to_copy; of_table[index].pointer += to_copy; fd_table[of_table[index].fd_index].length = of_table[index].pointer > fd_table[of_table[index].fd_index].length ? of_table[index].pointer : fd_table[of_table[index].fd_index].length;
printf("Wrote %zu bytes to block %zu at offset %zu.\n", to_copy, block_index, offset);
printf("Current buffer pointer: %zu\n", of_table[index].pointer);
printf("Buffer after write: %.50s...\n", of_table[index].buffer);
write_block(fd_table[of_table[index].fd_index].blocks[block_index], of_table[index].buffer);
printf("Buffer written to disk: %.50s...\n", of_table[index].buffer);
} else {
break;
}
}
printf("Total bytes written: %zu\n", bytes_written);
return bytes_written;
}
printf("Invalid file descriptor index %d.\n", index);
return -1;
}
读取文件
当用户调用 read 命令时，我们需要从文件的当前指针位置读取指定数量的数据。相关代码如下：
size_t read(int index, char *mem_area, size_t count) {
if (index >= 0 && index < MAX_FILES && of_table[index].fd_index != -1) {
size_t bytes_read = 0;
while (bytes_read < count && of_table[index].pointer < fd_table[of_table[index].fd_index].length) {
size_t offset = of_table[index].pointer % B;
size_t block_index = of_table[index].pointer / B;
size_t remaining = B - offset;
size_t to_copy = remaining < (count - bytes_read) ? remaining : (count - bytes_read);
if (block_index < K - 1 && fd_table[of_table[index].fd_index].blocks[block_index]) {
if (offset == 0) {
read_block(fd_table[of_table[index].fd_index].blocks[block_index], of_table[index].buffer);
printf("Buffer after read: %.50s...\n", of_table[index].buffer);
}
memcpy(mem_area + bytes_read, of_table[index].buffer + offset, to_copy);
bytes_read += to_copy;
of_table[index].pointer += to_copy;
printf("Read %zu bytes from block %zu at offset %zu.\n", to_copy, block_index, offset);
printf("Current buffer pointer: %zu\n", of_table[index].pointer);
} else {
break;
}
}
mem_area[bytes_read] = '\0'; // Null-terminate the string for safe printing
printf("Total bytes read: %zu\n", bytes_read);
printf("Data read: %.50s...\n", mem_area);
return bytes_read;
}
printf("Invalid file descriptor index %d.\n", index);
return -1;
}
目录操作
列出目录
当用户调用 directory 命令时，我们需要遍历目录并列出所有文件的名称及其长度。相关代码如下：
void directory() {
printf("Filename\tLength\n");
for (int i = 1; i < MAX_FILES; i++) { if (fd_table[i].length > 0) {
char filename[MAX_FILENAME_LENGTH];
get_filename_from_directory(i, filename);
printf("%s\t%d\n", filename, fd_table[i].length);
}
}
}
实验结果
通过上述功能的实现，我们成功构建了一个简单的文件系统。以下是一些测试命令及预期输出：
创建文件
> create file1.txt Found free block 10. Added file 'file1.txt' with fd_index 1 to directory. Created file 'file1.txt' with fd_index 1 and initial block 10. File 'file1.txt' created successfully.
打开文件
> open file1.txt Read block 10 into memory. Open file table slot 0 used for fd_index 1 File 'file1.txt' opened successfully with index 0.
写入文件
> write 0 Hello, World! Writing 'Hello, World!' with length 13 to file index 0 Found free block 11.Read block 11 into memory. Buffer after read: Wrote 13 bytes to block 0 at offset 0. Current buffer pointer: 13 Buffer after write: Hello, World!... Wrote to block 11 from memory. Buffer written to disk: Hello, World!... Total bytes written: 13 Wrote 13 bytes to file with index 0.
读取文件
> read 0 13 Buffer after read: Hello, World!... Read 13 bytes from block 0 at offset 0. Current buffer pointer: 13 Total bytes read: 13 Data read: Hello, World!...
关闭文件
> close 0 Wrote to block 11 from memory. Closed file descriptor index 0
列出目录
> directory Filename Length file1.txt 13
删除文件
> destroy file1.txt Freed block 10 associated with fd_index 1. Freed block 11 associated with fd_index 1. All blocks freed for fd_index 1. Removed file 'file1.txt' from directory. Destroyed file 'file1.txt' with fd_index 1.
结论
通过本次实验，我成功实现了基本的文件系统功能，包括文件的创建、删除、打开、关闭、读取和写入等操作。虽然这是一个简化的版本，但它展示了文件系统的核心原理和技术细节。未来可以在此基础上扩展更多高级特性，如多级索引、日志记录和错误处理等。
源代码附录
#include
#include
#include
#define L 1024 // 磁盘总块数
#define B 512 // 每个存储块的长度
#define K 10 // 保留区块数
#define MAX_FILES 100 // 最大文件数量
#define MAX_FILENAME_LENGTH 32
char ldisk[L][B]; // 模拟磁盘
int bitmap[L]; // 位示图
// 结构体定义
struct file_descriptor {
int length;
int blocks[K - 1];
};
struct open_file_entry {
char buffer[B];
size_t pointer;
int fd_index;
};
struct directory_entry {
char name[MAX_FILENAME_LENGTH];
int fd_index;
};
struct file_descriptor fd_table[MAX_FILES];
struct open_file_entry of_table[MAX_FILES];
int of_count = 0;
// 辅助函数声明
int find_free_block();
void add_to_directory(const char *filename, int fd_index);
void free_blocks(int fd_index);
void remove_from_directory(const char *filename);
int find_in_directory(const char *filename);
void get_filename_from_directory(int fd_index, char *filename);
int is_file_open(int fd_index);
// 初始化文件系统
void init_fs() {
memset(ldisk, 0, sizeof(ldisk));
memset(bitmap, 0, sizeof(bitmap));
memset(fd_table, 0, sizeof(fd_table));
for (int i = 0; i < MAX_FILES; i++) { of_table[i].fd_index = -1; } printf("File system initialized.\n"); } // 读取逻辑块 int read_block(int i, char *p) { if (i >= 0 && i < L) { memcpy(p, ldisk[i], B); printf("Read block %d into memory.\n", i); return B; } printf("Invalid block index %d for reading.\n", i); return 0; } // 写入逻辑块 int write_block(int i, const char *p) { if (i >= 0 && i < L) {
memcpy(ldisk[i], p, B);
printf("Wrote to block %d from memory.\n", i);
return B;
}
printf("Invalid block index %d for writing.\n", i);
return 0;
}
// 创建文件
int create(const char *filename) {
for (int i = 1; i < MAX_FILES; i++) { // 从索引1开始，因为0用于目录
if (fd_table[i].length == 0) {
fd_table[i].blocks[0] = find_free_block();
if (fd_table[i].blocks[0] == -1) {
printf("No free blocks available for creating file '%s'.\n", filename);
return -1;
}
bitmap[fd_table[i].blocks[0]] = 1;
add_to_directory(filename, i);
printf("Created file '%s' with fd_index %d and initial block %d.\n", filename, i, fd_table[i].blocks[0]);
return 0;
}
}
printf("Maximum number of files reached. Cannot create file '%s'.\n", filename);
return -1;
}
// 删除文件
int destroy(const char *filename) {
int fd_index = find_in_directory(filename);
if (fd_index == -1) {
printf("File '%s' not found in directory.\n", filename);
return -1;
}
if (is_file_open(fd_index)) {
printf("Cannot destroy file '%s' as it is currently open.\n", filename);
return -1;
}
free_blocks(fd_index);
remove_from_directory(filename);
printf("Destroyed file '%s' with fd_index %d.\n", filename, fd_index);
return 0;
}
// 打开文件
int open(const char *filename) {
int fd_index = find_in_directory(filename);
if (fd_index == -1) {
printf("File '%s' not found.\n", filename);
return -1;
}
if (is_file_open(fd_index)) {
printf("File '%s' already open.\n", filename);
return -1;
}
for (int i = 0; i < MAX_FILES; i++) { if (of_table[i].fd_index == -1) { of_table[i].fd_index = fd_index; of_table[i].pointer = 0; read_block(fd_table[fd_index].blocks[0], of_table[i].buffer); of_count++; printf("Open file table slot %d used for fd_index %d\n", i, fd_index); return i; } } printf("No available slots in open file table.\n"); return -1; } // 关闭文件 int close(int index) { if (index >= 0 && index < MAX_FILES && of_table[index].fd_index != -1) { write_block(fd_table[of_table[index].fd_index].blocks[0], of_table[index].buffer); of_table[index].fd_index = -1; of_count--; printf("Closed file descriptor index %d\n", index); return 0; } printf("Invalid file descriptor index %d.\n", index); return -1; } // 读取文件 size_t read(int index, char *mem_area, size_t count) { if (index >= 0 && index < MAX_FILES && of_table[index].fd_index != -1) {
size_t bytes_read = 0;
while (bytes_read < count && of_table[index].pointer < fd_table[of_table[index].fd_index].length) {
size_t offset = of_table[index].pointer % B;
size_t block_index = of_table[index].pointer / B;
size_t remaining = B - offset;
size_t to_copy = remaining < (count - bytes_read) ? remaining : (count - bytes_read);
if (block_index < K - 1 && fd_table[of_table[index].fd_index].blocks[block_index]) { if (offset == 0) { read_block(fd_table[of_table[index].fd_index].blocks[block_index], of_table[index].buffer); printf("Buffer after read: %.50s...\n", of_table[index].buffer); } memcpy(mem_area + bytes_read, of_table[index].buffer + offset, to_copy); bytes_read += to_copy; of_table[index].pointer += to_copy; printf("Read %zu bytes from block %zu at offset %zu.\n", to_copy, block_index, offset); printf("Current buffer pointer: %zu\n", of_table[index].pointer); } else { break; } } mem_area[bytes_read] = '\0'; // Null-terminate the string for safe printing printf("Total bytes read: %zu\n", bytes_read); printf("Data read: %.50s...\n", mem_area); return bytes_read; } printf("Invalid file descriptor index %d.\n", index); return -1; } // 写入文件 size_t write(int index, const char *mem_area, size_t count) { if (index >= 0 && index < MAX_FILES && of_table[index].fd_index != -1) {
size_t bytes_written = 0;
while (bytes_written < count) {
size_t offset = of_table[index].pointer % B;
size_t block_index = of_table[index].pointer / B;
size_t remaining = B - offset;
size_t to_copy = remaining < (count - bytes_written) ? remaining : (count - bytes_written);
if (block_index < K - 1) { if (offset == 0 || fd_table[of_table[index].fd_index].blocks[block_index] == 0) { fd_table[of_table[index].fd_index].blocks[block_index] = find_free_block(); if (fd_table[of_table[index].fd_index].blocks[block_index] == -1) break; bitmap[fd_table[of_table[index].fd_index].blocks[block_index]] = 1; } read_block(fd_table[of_table[index].fd_index].blocks[block_index], of_table[index].buffer); printf("Buffer after read: %.50s...\n", of_table[index].buffer); memcpy(of_table[index].buffer + offset, mem_area + bytes_written, to_copy); bytes_written += to_copy; of_table[index].pointer += to_copy; fd_table[of_table[index].fd_index].length = of_table[index].pointer > fd_table[of_table[index].fd_index].length ? of_table[index].pointer : fd_table[of_table[index].fd_index].length;
printf("Wrote %zu bytes to block %zu at offset %zu.\n", to_copy, block_index, offset);
printf("Current buffer pointer: %zu\n", of_table[index].pointer);
printf("Buffer after write: %.50s...\n", of_table[index].buffer);
write_block(fd_table[of_table[index].fd_index].blocks[block_index], of_table[index].buffer);
printf("Buffer written to disk: %.50s...\n", of_table[index].buffer);
} else {
break;
}
}
printf("Total bytes written: %zu\n", bytes_written);
return bytes_written;
}
printf("Invalid file descriptor index %d.\n", index);
return -1;
}
// 移动文件指针
int lseek(int index, size_t pos) {
if (index >= 0 && index < MAX_FILES && of_table[index].fd_index != -1) {
of_table[index].pointer = pos;
size_t block_index = of_table[index].pointer / B;
if (block_index < K - 1 && fd_table[of_table[index].fd_index].blocks[block_index]) {
read_block(fd_table[of_table[index].fd_index].blocks[block_index], of_table[index].buffer);
printf("Buffer after read: %.50s...\n", of_table[index].buffer);
}
printf("Moved pointer in file with index %d to position %zu.\n", index, pos);
return 0;
}
printf("Invalid file descriptor index %d.\n", index);
return -1;
}
// 列出目录
void directory() {
printf("Filename\tLength\n");
for (int i = 1; i < MAX_FILES; i++) { if (fd_table[i].length > 0) {
char filename[MAX_FILENAME_LENGTH];
get_filename_from_directory(i, filename);
printf("%s\t%d\n", filename, fd_table[i].length);
}
}
}
// 辅助函数：查找空闲块
int find_free_block() {
for (int i = K; i < L; i++) {
if (!bitmap[i]) {
printf("Found free block %d.\n", i);
return i;
}
}
printf("No free blocks available.\n");
return -1;
}
// 辅助函数：添加到目录
void add_to_directory(const char *filename, int fd_index) {
size_t dir_length = fd_table[0].length;
size_t block_index = dir_length / B;
size_t offset = dir_length % B;
struct directory_entry entry;
strncpy(entry.name, filename, MAX_FILENAME_LENGTH);
entry.fd_index = fd_index;
if (dir_length == 0) {
fd_table[0].blocks[0] = find_free_block();
bitmap[fd_table[0].blocks[0]] = 1;
}
read_block(fd_table[0].blocks[block_index], ldisk[0]);
memcpy(ldisk[0] + offset, &entry, sizeof(struct directory_entry));
write_block(fd_table[0].blocks[block_index], ldisk[0]);
fd_table[0].length += sizeof(struct directory_entry);
printf("Added file '%s' with fd_index %d to directory.\n", filename, fd_index);
}
// 辅助函数：释放块
void free_blocks(int fd_index) {
for (int i = 0; i < K - 1; i++) {
if (fd_table[fd_index].blocks[i]) {
bitmap[fd_table[fd_index].blocks[i]] = 0;
printf("Freed block %d associated with fd_index %d.\n", fd_table[fd_index].blocks[i], fd_index);
fd_table[fd_index].blocks[i] = 0;
} else break;
}
fd_table[fd_index].length = 0;
printf("All blocks freed for fd_index %d.\n", fd_index);
}
// 辅助函数：从目录中删除
void remove_from_directory(const char *filename) {
size_t dir_length = fd_table[0].length;
for (size_t i = 0; i < dir_length / sizeof(struct directory_entry); i++) {
struct directory_entry entry;
size_t block_index = i * sizeof(struct directory_entry) / B;
size_t offset = i * sizeof(struct directory_entry) % B;
read_block(fd_table[0].blocks[block_index], ldisk[0]);
memcpy(&entry, ldisk[0] + offset, sizeof(struct directory_entry));
if (strcmp(entry.name, filename) == 0) {
for (size_t j = i; j < dir_length / sizeof(struct directory_entry) - 1; j++) {
struct directory_entry next_entry;
size_t next_block_index = (j + 1) * sizeof(struct directory_entry) / B;
size_t next_offset = (j + 1) * sizeof(struct directory_entry) % B;
read_block(fd_table[0].blocks[next_block_index], ldisk[0]);
memcpy(&next_entry, ldisk[0] + next_offset, sizeof(struct directory_entry));
memcpy(ldisk[0] + offset, &next_entry, sizeof(struct directory_entry));
write_block(fd_table[0].blocks[block_index], ldisk[0]);
offset += sizeof(struct directory_entry);
if (offset == B) {
block_index++;
offset = 0;
}
}
fd_table[0].length -= sizeof(struct directory_entry);
printf("Removed file '%s' from directory.\n", filename);
return;
}
}
printf("File '%s' not found in directory.\n", filename);
}
// 辅助函数：查找目录项
int find_in_directory(const char *filename) {
size_t dir_length = fd_table[0].length;
for (size_t i = 0; i < dir_length / sizeof(struct directory_entry); i++) {
struct directory_entry entry;
size_t block_index = i * sizeof(struct directory_entry) / B;
size_t offset = i * sizeof(struct directory_entry) % B;
read_block(fd_table[0].blocks[block_index], ldisk[0]);
memcpy(&entry, ldisk[0] + offset, sizeof(struct directory_entry));
if (strcmp(entry.name, filename) == 0) {
printf("Found file '%s' with fd_index %d\n", filename, entry.fd_index);
return entry.fd_index;
}
}
printf("File '%s' not found in directory\n", filename);
return -1;
}
// 辅助函数：获取目录项名称
void get_filename_from_directory(int fd_index, char *filename) {
size_t dir_length = fd_table[0].length;
for (size_t i = 0; i < dir_length / sizeof(struct directory_entry); i++) {
struct directory_entry entry;
size_t block_index = i * sizeof(struct directory_entry) / B;
size_t offset = i * sizeof(struct directory_entry) % B;
read_block(fd_table[0].blocks[block_index], ldisk[0]);
memcpy(&entry, ldisk[0] + offset, sizeof(struct directory_entry));
if (entry.fd_index == fd_index) {
strcpy(filename, entry.name);
return;
}
}
filename[0] = '\0';
}
// 辅助函数：检查文件是否已打开
int is_file_open(int fd_index) {
for (int i = 0; i < MAX_FILES; i++) { if (of_table[i].fd_index == fd_index) { printf("File with fd_index %d is already open\n", fd_index); return 1; } } return 0; } // 命令解析器 void command_parser() { char line[200]; char command[100]; char arg1[100]; size_t arg3; char *context = NULL; // 上下文指针 while (1) { printf("> ");
fgets(line, sizeof(line), stdin);
char *token = strtok_r(line, " ", &context);
if (token == NULL) continue;
strcpy(command, token);
if (strcmp(command, "create") == 0) {
token = strtok_r(NULL, " \n", &context);
if (token != NULL) {
strcpy(arg1, token);
if (create(arg1) == 0) {
printf("File '%s' created successfully.\n", arg1);
} else {
printf("Failed to create file '%s'.\n", arg1);
}
} else {
printf("No filename provided.\n");
}
} else if (strcmp(command, "destroy") == 0) {
token = strtok_r(NULL, " \n", &context);
if (token != NULL) {
strcpy(arg1, token);
if (destroy(arg1) == 0) {
printf("File '%s' destroyed successfully.\n", arg1);
} else {
printf("Failed to destroy file '%s'.\n", arg1);
}
} else {
printf("No filename provided.\n");
}
} else if (strcmp(command, "open") == 0) {
token = strtok_r(NULL, " \n", &context);
if (token != NULL) {
strcpy(arg1, token);
int fd = open(arg1);
if (fd != -1) {
printf("File '%s' opened successfully with index %d.\n", arg1, fd);
} else {
printf("Failed to open file '%s'.\n", arg1);
}
} else {
printf("No filename provided.\n");
}
} else if (strcmp(command, "close") == 0) {
token = strtok_r(NULL, " \n", &context);
if (token != NULL) {
arg3 = atoi(token);
if (close(arg3) == 0) {
printf("File with index %zu closed successfully.\n", arg3);
} else {
printf("Failed to close file with index %zu.\n", arg3);
}
} else {
printf("No file descriptor index provided.\n");
}
} else if (strcmp(command, "read") == 0) {
token = strtok_r(NULL, " ", &context);
if (token != NULL) {
arg3 = atoi(token);
token = strtok_r(NULL, " \n", &context);
if (token != NULL) {
size_t size = atoi(token);
char *buffer = (char *)malloc(size + 1);
if (buffer == NULL) {
printf("Memory allocation failed.\n");
continue;
}
size_t bytes_read = read(arg3, buffer, size);
if (bytes_read > 0) {
buffer[bytes_read] = '\0';
printf("Read %zu bytes: %s\n", bytes_read, buffer);
} else {
printf("Failed to read from file with index %zu.\n", arg3);
}
free(buffer);
} else {
printf("No size provided for read operation.\n");
}
} else {
printf("No file descriptor index provided for read operation.\n");
}
} else if (strcmp(command, "write") == 0) {
token = strtok_r(NULL, " ", &context);
if (token != NULL) {
arg3 = atoi(token);
token = strtok_r(NULL, "\n", &context);
if (token != NULL) {
size_t size = strlen(token);
printf("Writing '%s' with length %zu to file index %zu\n", token, size, arg3);
if (write(arg3, token, size) == size) {
printf("Wrote %zu bytes to file with index %zu.\n", size, arg3);
} else {
printf("Failed to write to file with index %zu.\n", arg3);
}
} else {
printf("No data provided to write.\n");
}
} else {
printf("No file descriptor index provided for write operation.\n");
}
} else if (strcmp(command, "lseek") == 0) {
token = strtok_r(NULL, " ", &context);
if (token != NULL) {
arg3 = atoi(token);
token = strtok_r(NULL, " ", &context);
if (token != NULL) {
size_t pos = atoi(token);
if (lseek(arg3, pos) == 0) {
printf("Moved pointer in file with index %zu to position %zu.\n", arg3, pos);
} else {
printf("Failed to move pointer in file with index %zu.\n", arg3);
}
} else {
printf("No position provided for lseek operation.\n");
}
} else {
printf("No file descriptor index provided for lseek operation.\n");
}
} else if (strcmp(command, "directory") == 0) {
directory();
} else if (strcmp(command, "exit") == 0) {
printf("Exiting...\n");
break;
} else {
printf("Unknown command. Try again.\n");
}
}
}
int main() {
init_fs();
command_parser();
return 0;
}
