FS.c

#define FUSE_USE_VERSION 30

#include <fuse.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <errno.h>

/*
 * 编译和挂载文件系统说明
 *
 * 1. 编译文件系统：
 *    使用以下命令编译文件系统代码：
 *    gcc FS.c -o FS `pkg-config fuse --cflags --libs`
 *
 *    参数说明：
 *    - gcc FS.c: 编译 FS.c 文件。
 *    - -o FS: 指定输出文件名为 FS。
 *    - `pkg-config fuse --cflags --libs`: 自动获取 FUSE 库的编译和链接参数。
 *
 * 2. 挂载文件系统：
 *    使用以下命令挂载文件系统：
 *    ./FS -f Desktop/OS/mountpoint4
 *
 *    参数说明：
 *    - ./FS: 运行编译生成的文件系统程序。
 *    - -f: 在前台运行文件系统（调试模式），程序会输出日志信息。
 *    - Desktop/OS/mountpoint4: 挂载点路径，文件系统将挂载到该目录。
 *
 * 3. 挂载后的操作：
 *    挂载成功后，可以通过挂载点路径（如 Desktop/OS/mountpoint4）访问文件系统：
 *    - 创建文件: touch Desktop/OS/mountpoint4/test.txt
 *    - 读取文件: cat Desktop/OS/mountpoint4/test.txt
 *    - 删除文件: rm Desktop/OS/mountpoint4/test.txt
 *
 * 4. 卸载文件系统：
 *    使用以下命令卸载文件系统：
 *    fusermount -u Desktop/OS/mountpoint4
 *
 *    参数说明：
 *    - fusermount -u: 卸载文件系统。
 *    - Desktop/OS/mountpoint4: 挂载点路径。
 *
 * 5. 调试模式：
 *    如果使用 -f 参数在前台运行文件系统，程序会输出日志信息，方便调试。例如：
 *    OPEN /test.txt
 *    READ /test.txt
 *    CLOSE /test.txt
 *
 * 注意事项：
 * 1. 确保挂载点路径存在且为空目录。
 * 2. 如果挂载失败，检查是否有权限问题或路径错误。
 * 3. 调试完成后，可以去掉 -f 参数，让文件系统在后台运行。
 */

#define block_size 1024

/*
 * superblock - 文件系统超级块结构
 *
 * 功能：
 * 1. 存储文件系统的全局元数据信息。
 * 2. 管理数据块和 inode 的分配状态。
 *
 * 字段说明：
 * - datablocks: 数据块数组，存储文件系统的所有数据块。
 * - data_bitmap: 数据块位图，标识哪些数据块已被占用（'1'）或空闲（'0'）。
 * - inode_bitmap: inode 位图，标识哪些 inode 已被占用（'1'）或空闲（'0'）。
 *
 * 示例：
 * 假设文件系统刚初始化，调用 initialize_superblock() 后：
 * - spblock.data_bitmap 的所有位均为 '0'，表示所有数据块空闲。
 * - spblock.inode_bitmap 的所有位均为 '0'，表示所有 inode 空闲。
 *
 * 注意：
 * - 超级块是文件系统的核心数据结构，必须在文件系统初始化时调用 initialize_superblock() 方法。
 * - 数据块位图和 inode 位图的大小固定为 100 个字节。
 */
typedef struct superblock
{
	char datablocks[block_size * 100]; // 数据块数组，存储文件系统的所有数据块
	char data_bitmap[105];			   // 数据块位图，标识数据块的占用状态
	char inode_bitmap[105];			   // inode 位图，标识 inode 的占用状态
} superblock;

/*
 * inode - 文件系统索引节点结构
 *
 * 功能：
 * 1. 存储文件或目录的元数据信息。
 * 2. 管理文件数据块的分配和引用。
 *
 * 字段说明：
 * - datablocks: 数据块编号数组，存储文件数据所在的数据块。
 * - number: inode 的唯一标识符。
 * - blocks: 文件占用的数据块数量。
 * - size: 文件或目录的大小（以字节为单位）。
 *
 * 示例：
 * 假设文件系统结构如下：
 * /
 * ├── home
 * │   └── user
 * └── test.txt
 *
 * inode 示例：
 * inode (test.txt):
 * - datablocks: [5, 6, 7]  // 文件数据存储在数据块 5、6、7 中
 * - number: 3              // inode 编号为 3
 * - blocks: 3              // 文件占用 3 个数据块
 * - size: 3072             // 文件大小为 3072 字节
 *
 * 注意：
 * - inode 是文件系统的核心数据结构，用于管理文件的元数据和数据块。
 * - 每个文件或目录都有一个唯一的 inode。
 */
typedef struct inode
{
	int datablocks[16]; // 数据块编号数组，存储文件数据所在的数据块
	int number;			// inode 的唯一标识符
	int blocks;			// 文件占用的数据块数量
	// int link;                    //==number of links
	int size; // 文件或目录的大小（以字节为单位）
} inode;

/*
 * filetype - 文件/目录元数据结构
 *
 * 功能：
 * 1. 存储文件或目录的元数据信息。
 * 2. 用于管理文件系统的树形结构。
 *
 * 字段说明：
 * - valid: 标识节点是否有效（1 表示有效，0 表示无效）。
 * - test: 保留字段，未使用。
 * - path: 文件或目录的完整路径。
 * - name: 文件或目录的名称。
 * - inum: 指向关联的 inode 结构。
 * - children: 子节点指针数组，用于存储目录的子文件或子目录。
 * - num_children: 子节点数量。
 * - num_links: 硬链接数。
 * - parent: 指向父目录的指针。
 * - type: 文件类型（如 "file" 或 "directory"）。
 * - permissions: 文件或目录的权限模式（如 0777）。
 * - user_id: 文件或目录的用户 ID。
 * - group_id: 文件或目录的组 ID。
 * - a_time: 最后访问时间。
 * - m_time: 最后修改时间。
 * - c_time: 最后状态更改时间。
 * - b_time: 创建时间。
 * - size: 文件或目录的大小（以字节为单位）。
 * - datablocks: 数据块编号数组，存储文件数据所在的数据块。
 * - number: 文件或目录的编号（唯一标识）。
 * - blocks: 文件占用的数据块数量。
 *
 * 示例：
 * 假设文件系统结构如下：
 * /
 * ├── home
 * │   └── user
 * └── test.txt
 *
 * 文件类型示例：
 * Filetype (Root):
 * - valid: 1
 * - path: "/"
 * - name: "/"
 * - type: "directory"
 * - permissions: 0777
 * - user_id: 1000
 * - group_id: 1000
 * - a_time: 1698765432
 * - m_time: 1698765432
 * - c_time: 1698765432
 * - b_time: 1698765432
 * - size: 4096
 * - number: 1
 * - blocks: 1
 * - children: [Filetype (home), Filetype (test.txt)]
 * - num_children: 2
 * - parent: NULL
 * - num_links: 2
 *
 * 注意：
 * - 文件类型和目录类型使用相同的结构体。
 * - 目录的 size 字段通常表示目录元数据的大小。
 */
typedef struct filetype
{
	int valid;					// 标识节点是否有效
	char test[10];				// 保留字段，未使用
	char path[100];				// 文件或目录的完整路径
	char name[100];				// 文件或目录的名称
	inode *inum;				// 指向关联的 inode 结构
	struct filetype **children; // 子节点指针数组
	int num_children;			// 子节点数量
	int num_links;				// 硬链接数
	struct filetype *parent;	// 指向父目录的指针
	char type[20];				// 文件类型（如 "file" 或 "directory"）
	mode_t permissions;			// 文件或目录的权限模式
	uid_t user_id;				// 用户 ID
	gid_t group_id;				// 组 ID
	time_t a_time;				// 最后访问时间
	time_t m_time;				// 最后修改时间
	time_t c_time;				// 最后状态更改时间
	time_t b_time;				// 创建时间
	off_t size;					// 文件或目录的大小
	int datablocks[16];			// 数据块编号数组
	int number;					// 文件或目录的编号
	int blocks;					// 文件占用的数据块数量
} filetype;

superblock spblock;
/*
 * initialize_superblock - 初始化超级块
 *
 * 功能：
 * 1. 初始化文件系统的超级块结构。
 * 2. 将数据块位图和 inode 位图初始化为全 0，表示所有数据块和 inode 均为空闲状态。
 *
 * 参数：
 * - 无。
 *
 * 返回值：
 * - 无。
 *
 * 实现逻辑：
 * 1. 使用 memset 将数据块位图（spblock.data_bitmap）初始化为全 0。
 * 2. 使用 memset 将 inode 位图（spblock.inode_bitmap）初始化为全 0。
 *
 * 示例：
 * 假设文件系统刚创建，调用 initialize_superblock() 后：
 * - spblock.data_bitmap 的所有位均为 0，表示所有数据块空闲。
 * - spblock.inode_bitmap 的所有位均为 0，表示所有 inode 空闲。
 *
 * 注意：
 * - 超级块是文件系统的核心数据结构，必须在文件系统初始化时调用此方法。
 * - 数据块位图和 inode 位图的大小固定为 100 个字节。
 */
void initialize_superblock()
{

	memset(spblock.data_bitmap, '0', 100 * sizeof(char));
	memset(spblock.inode_bitmap, '0', 100 * sizeof(char));
}

filetype *root;

filetype file_array[50];

/*
 * tree_to_array - 将文件树结构序列化为数组
 *
 * 功能：
 * 1. 通过广度优先遍历（BFS）将文件树结构扁平化为数组。
 * 2. 将树中的每个节点按遍历顺序存储到数组中。
 * 3. 使用无效节点（valid = 0）填充空位，确保数组长度固定。
 *
 * 参数：
 * - queue: 用于广度优先遍历的队列，存储待处理的节点。
 * - front: 队列的起始索引，指向当前处理的节点。
 * - rear: 队列的结束索引，指向下一个可插入的位置。
 * - index: 当前数组的索引，指向下一个可存储的位置。
 *
 * 实现逻辑：
 * 1. 从队列中取出当前节点（queue[*front]），并将其存储到数组（file_array[*index]）中。
 * 2. 如果当前节点有效（valid = 1），将其子节点加入队列。
 * 3. 如果当前节点无效或子节点不足 5 个，用无效节点填充队列。
 * 4. 递归处理队列中的下一个节点，直到队列为空或数组已满。
 *
 * 示例：
 * 假设文件树结构如下：
 * /
 * ├── home
 * │   └── user
 * └── test.txt
 *
 * 序列化后的数组布局如下：
 * Filetype 0 (Root):
 * - valid: 1
 * - path: "/"
 * - name: "/"
 * - type: "directory"
 * - children: [Filetype 1, Filetype 2]
 *
 * Filetype 1 (home):
 * - valid: 1
 * - path: "/home"
 * - name: "home"
 * - type: "directory"
 * - children: [Filetype 3]
 *
 * Filetype 2 (test.txt):
 * - valid: 1
 * - path: "/test.txt"
 * - name: "test.txt"
 * - type: "file"
 * - children: []
 *
 * Filetype 3 (user):
 * - valid: 1
 * - path: "/home/user"
 * - name: "user"
 * - type: "directory"
 * - children: []
 *
 * Filetype 4-30:
 * - valid: 0 (无效节点，用于占位)
 *
 * 注意：
 * - 数组长度固定为 31，包括无效节点。
 * - 每个节点最多有 5 个子节点。
 */
void tree_to_array(filetype *queue, int *front, int *rear, int *index)
{

	if (rear < front)
		return;
	if (*index > 30)
		return;

	filetype curr_node = queue[*front];
	*front += 1;
	file_array[*index] = curr_node;
	*index += 1;

	if (*index < 6)
	{

		if (curr_node.valid)
		{
			int n = 0;
			int i;
			for (i = 0; i < curr_node.num_children; i++)
			{
				if (*rear < *front)
					*rear = *front;
				queue[*rear] = *(curr_node.children[i]);
				*rear += 1;
			}
			while (i < 5)
			{
				filetype waste_node;
				waste_node.valid = 0;
				queue[*rear] = waste_node;
				*rear += 1;
				i++;
			}
		}
		else
		{
			int i = 0;
			while (i < 5)
			{
				filetype waste_node;
				waste_node.valid = 0;
				queue[*rear] = waste_node;
				*rear += 1;
				i++;
			}
		}
	}

	tree_to_array(queue, front, rear, index);
}

/*
 * save_contents - 保存文件系统内容到磁盘
 *
 * 功能：
 * 1. 将内存中的文件树结构通过广度优先遍历序列化为数组。
 * 2. 将序列化后的数组和超级块分别保存到 `file_structure.bin` 和 `super.bin` 文件中。
 *
 * 文件布局：
 * - `file_structure.bin` 存储文件树的所有节点信息，按广度优先遍历顺序扁平化为数组。
 *   - 每个节点包含文件/目录的元数据，如路径、名称、类型、权限、时间戳等。
 *   - 无效节点（valid = 0）用于占位，确保数组长度固定。
 *   - 在内存中，通过 children 指针重建树结构。
 * - `super.bin` 存储超级块信息，包括数据块和 inode 的位图。
 *
 * 示例：
 * 假设文件系统结构如下：
 * /
 * ├── home
 * │   └── user
 * └── test.txt
 *
 * `file_structure.bin` 的布局可能如下：
 * Filetype 0 (Root):
 * - valid: 1
 * - path: "/"
 * - name: "/"
 * - type: "directory"
 * - children: [Filetype 1, Filetype 2]
 *
 * Filetype 1 (home):
 * - valid: 1
 * - path: "/home"
 * - name: "home"
 * - type: "directory"
 * - children: [Filetype 3]
 *
 * Filetype 2 (test.txt):
 * - valid: 1
 * - path: "/test.txt"
 * - name: "test.txt"
 * - type: "file"
 * - children: []
 *
 * Filetype 3 (user):
 * - valid: 1
 * - path: "/home/user"
 * - name: "user"
 * - type: "directory"
 * - children: []
 *
 * Filetype 4-30:
 * - valid: 0 (无效节点，用于占位)
 *
 * 流程：
 * 1. 初始化队列，将根节点加入队列。
 * 2. 通过广度优先遍历将文件树序列化为数组。
 * 3. 将序列化后的数组写入 `file_structure.bin`。
 * 4. 将超级块写入 `super.bin`。
 *
 * 注意：
 * - 文件树最多支持 31 个节点（包括无效节点）。
 * - 每个节点最多有 5 个子节点。
 */
int save_contents()
{
	printf("SAVING\n");
	filetype *queue = malloc(sizeof(filetype) * 60);
	int front = 0;
	int rear = 0;
	queue[0] = *root;
	int index = 0;
	tree_to_array(queue, &front, &rear, &index);

	for (int i = 0; i < 31; i++)
	{
		printf("%d", file_array[i].valid);
	}

	FILE *fd = fopen("file_structure.bin", "wb");

	FILE *fd1 = fopen("super.bin", "wb");

	fwrite(file_array, sizeof(filetype) * 31, 1, fd);
	fwrite(&spblock, sizeof(superblock), 1, fd1);

	fclose(fd);
	fclose(fd1);

	printf("\n");
}

/*
 * initialize_root_directory - 初始化根目录
 *
 * 功能：
 * 1. 创建并初始化文件系统的根目录。
 * 2. 设置根目录的元数据，包括路径、名称、类型、权限、时间戳等。
 * 3. 标记根目录的 inode 为已使用。
 * 4. 调用 save_contents 方法将初始化后的文件系统保存到磁盘。
 *
 * 实现逻辑：
 * 1. 在 inode 位图中标记根目录的 inode 为已使用（spblock.inode_bitmap[1] = 1）。
 * 2. 分配内存并初始化根目录结构（filetype）。
 * 3. 设置根目录的路径为 "/"，名称为 "/"。
 * 4. 设置根目录的类型为 "directory"，权限为 0777。
 * 5. 初始化时间戳（创建时间、访问时间、修改时间等）。
 * 6. 设置根目录的 inode 编号为 2。
 * 7. 调用 save_contents 方法保存文件系统。
 *
 * 初始化后的根目录结构示例：
 * Filetype (Root):
 * - valid: 1
 * - path: "/"
 * - name: "/"
 * - type: "directory"
 * - permissions: 0777
 * - user_id: 当前用户ID
 * - group_id: 当前组ID
 * - a_time: 当前时间
 * - m_time: 当前时间
 * - c_time: 当前时间
 * - b_time: 当前时间
 * - size: 0
 * - number: 2 (inode 编号)
 * - blocks: 0
 * - children: NULL
 * - num_children: 0
 * - parent: NULL
 * - num_links: 2
 *
 * 注意：
 * - 根目录的 inode 编号固定为 2。
 * - 根目录是文件系统的起点，所有其他文件和目录都是其子节点。
 */
void initialize_root_directory()
{

	spblock.inode_bitmap[1] = 1; // marking it with 0
	root = (filetype *)malloc(sizeof(filetype));

	strcpy(root->path, "/");
	strcpy(root->name, "/");

	root->children = NULL;
	root->num_children = 0;
	root->parent = NULL;
	root->num_links = 2;
	root->valid = 1;
	strcpy(root->test, "test");
	// root -> type = malloc(10);
	strcpy(root->type, "directory");

	root->c_time = time(NULL);
	root->a_time = time(NULL);
	root->m_time = time(NULL);
	root->b_time = time(NULL);

	root->permissions = S_IFDIR | 0777;

	root->size = 0;
	root->group_id = getgid();
	root->user_id = getuid();

	root->number = 2;
	// root -> size = 0;
	root->blocks = 0;

	save_contents();
}

/*
 * filetype_from_path - 根据路径查找对应的文件节点
 *
 * 功能：
 * 1. 根据给定的路径，在文件树中查找对应的文件或目录节点。
 * 2. 支持绝对路径（以 "/" 开头）的解析。
 * 3. 如果路径不存在，返回 NULL。
 *
 * 参数：
 * - path: 要查找的路径字符串（必须以 "/" 开头）。
 *
 * 返回值：
 * - 成功时返回对应的文件节点指针（filetype *）。
 * - 如果路径不存在或路径格式错误，返回 NULL。
 *
 * 实现逻辑：
 * 1. 检查路径是否以 "/" 开头，如果不是则报错并退出。
 * 2. 从根节点开始，逐级解析路径中的目录名。
 * 3. 在当前节点的子节点中查找匹配的目录或文件。
 * 4. 如果找到匹配的节点，返回该节点；否则返回 NULL。
 *
 * 示例：
 * 假设文件树结构如下：
 * /
 * ├── home
 * │   └── user
 * └── test.txt
 *
 * 调用示例：
 * 1. filetype_from_path("/") -> 返回根节点
 * 2. filetype_from_path("/home") -> 返回 home 目录节点
 * 3. filetype_from_path("/home/user") -> 返回 user 目录节点
 * 4. filetype_from_path("/test.txt") -> 返回 test.txt 文件节点
 * 5. filetype_from_path("/invalid") -> 返回 NULL
 *
 * 注意：
 * - 路径必须以 "/" 开头。
 * - 路径末尾的 "/" 会被自动去除。
 * - 如果路径不存在，返回 NULL。
 */
filetype *filetype_from_path(char *path)
{
	char curr_folder[100];
	char *path_name = malloc(strlen(path) + 2);

	strcpy(path_name, path);

	filetype *curr_node = root;

	fflush(stdin);

	if (strcmp(path_name, "/") == 0)
		return curr_node;

	if (path_name[0] != '/')
	{
		printf("INCORRECT PATH\n");
		exit(1);
	}
	else
	{
		path_name++;
	}

	if (path_name[strlen(path_name) - 1] == '/')
	{
		path_name[strlen(path_name) - 1] = '\0';
	}

	char *index;
	int flag = 0;

	while (strlen(path_name) != 0)
	{
		index = strchr(path_name, '/');

		if (index != NULL)
		{
			strncpy(curr_folder, path_name, index - path_name);
			curr_folder[index - path_name] = '\0';

			flag = 0;
			for (int i = 0; i < curr_node->num_children; i++)
			{
				if (strcmp((curr_node->children)[i]->name, curr_folder) == 0)
				{
					curr_node = (curr_node->children)[i];
					flag = 1;
					break;
				}
			}
			if (flag == 0)
				return NULL;
		}
		else
		{
			strcpy(curr_folder, path_name);
			flag = 0;
			for (int i = 0; i < curr_node->num_children; i++)
			{
				if (strcmp((curr_node->children)[i]->name, curr_folder) == 0)
				{
					curr_node = (curr_node->children)[i];
					return curr_node;
				}
			}
			return NULL;
		}
		path_name = index + 1;
	}
}
/*
 * find_free_inode - 查找空闲的 inode
 *
 * 功能：
 * 1. 查找当前文件系统中空闲的 inode 编号。
 * 2. 用于创建新文件或目录时分配 inode。
 *
 * 参数：
 * - 无。
 *
 * 返回值：
 * - 成功时返回空闲的 inode 编号。
 * - 如果没有空闲 inode，返回 -1。
 *
 * 实现逻辑：
 * 1. 遍历 inode 表，查找第一个空闲的 inode。
 * 2. 返回找到的 inode 编号。
 *
 * 注意：
 * - 如果 inode 表已满，需扩展文件系统。
 */
int find_free_inode()
{
	for (int i = 2; i < 100; i++)
	{
		if (spblock.inode_bitmap[i] == '0')
		{
			spblock.inode_bitmap[i] = '1';
		}
		return i;
	}
}
/*
 * find_free_db - 查找空闲的数据块
 *
 * 功能：
 * 1. 查找当前文件系统中空闲的数据块编号。
 * 2. 用于存储文件数据时分配数据块。
 *
 * 参数：
 * - 无。
 *
 * 返回值：
 * - 成功时返回空闲的数据块编号。
 * - 如果没有空闲数据块，返回 -1。
 *
 * 实现逻辑：
 * 1. 遍历数据块位图，查找第一个空闲的数据块。
 * 2. 返回找到的数据块编号。
 *
 * 注意：
 * - 如果数据块已满，需扩展文件系统。
 */
int find_free_db()
{
	for (int i = 1; i < 100; i++)
	{
		if (spblock.inode_bitmap[i] == '0')
		{
			spblock.inode_bitmap[i] = '1';
		}
		return i;
	}
}

/*
 * add_child - 添加子节点
 *
 * 功能：
 * 1. 将指定节点添加到父目录的子节点列表中。
 * 2. 更新父目录的子节点数量和列表。
 *
 * 参数：
 * - parent: 父目录节点。
 * - child: 要添加的子节点。
 *
 * 返回值：
 * - 无。
 *
 * 实现逻辑：
 * 1. 扩展父目录的子节点列表（如果需要）。
 * 2. 将子节点添加到列表中。
 * 3. 更新父目录的子节点数量。
 *
 * 注意：
 * - 确保父目录是目录类型。
 */
void add_child(filetype *parent, filetype *child)
{
	(parent->num_children)++;

	parent->children = realloc(parent->children, (parent->num_children) * sizeof(filetype *));

	(parent->children)[parent->num_children - 1] = child;
}

/*
 * mymkdir - 创建新目录
 *
 * 功能：
 * 1. 在指定路径下创建一个新目录。
 * 2. 分配并初始化新目录的元数据，包括路径、名称、类型、权限、时间戳等。
 * 3. 将新目录添加到父目录的子节点列表中。
 * 4. 调用 save_contents 方法将更新后的文件系统保存到磁盘。
 *
 * 参数：
 * - path: 新目录的完整路径（必须以 "/" 开头）。
 * - mode: 目录的权限模式（未直接使用，固定为 0777）。
 *
 * 返回值：
 * - 成功时返回 0。
 * - 如果父目录不存在，返回 -ENOENT。
 *
 * 实现逻辑：
 * 1. 查找一个空闲的 inode 编号。
 * 2. 解析路径，获取新目录的名称和父目录路径。
 * 3. 分配内存并初始化新目录结构（filetype）。
 * 4. 设置新目录的元数据，包括路径、名称、类型、权限、时间戳等。
 * 5. 将新目录添加到父目录的子节点列表中。
 * 6. 调用 save_contents 方法保存文件系统。
 *
 * 示例：
 * 假设文件系统结构如下：
 * /
 * └── home
 *
 * 调用示例：
 * 1. mymkdir("/home/user", 0777) -> 在 /home 下创建 user 目录
 *    - 新目录路径: "/home/user"
 *    - 新目录名称: "user"
 *    - 父目录: "/home"
 * 2. mymkdir("/invalid/path", 0777) -> 返回 -ENOENT（父目录不存在）
 *
 * 注意：
 * - 路径必须以 "/" 开头。
 * - 新目录的权限固定为 0777。
 * - 如果父目录不存在，操作失败。
 */
static int mymkdir(const char *path, mode_t mode)
{
	printf("MKDIR\n");

	int index = find_free_inode();

	filetype *new_folder = malloc(sizeof(filetype));

	char *pathname = malloc(strlen(path) + 2);
	strcpy(pathname, path);

	char *rindex = strrchr(pathname, '/');

	// new_folder -> name = malloc(strlen(pathname)+2);
	strcpy(new_folder->name, rindex + 1);
	// new_folder -> path = malloc(strlen(pathname)+2);
	strcpy(new_folder->path, pathname);

	*rindex = '\0';

	if (strlen(pathname) == 0)
		strcpy(pathname, "/");

	new_folder->children = NULL;
	new_folder->num_children = 0;
	new_folder->parent = filetype_from_path(pathname);
	new_folder->num_links = 2;
	new_folder->valid = 1;
	strcpy(new_folder->test, "test");

	if (new_folder->parent == NULL)
		return -ENOENT;

	// printf(";;;;%p;;;;\n", new_folder);

	add_child(new_folder->parent, new_folder);

	// new_folder -> type = malloc(10);
	strcpy(new_folder->type, "directory");

	new_folder->c_time = time(NULL);
	new_folder->a_time = time(NULL);
	new_folder->m_time = time(NULL);
	new_folder->b_time = time(NULL);

	new_folder->permissions = S_IFDIR | 0777;

	new_folder->size = 0;
	new_folder->group_id = getgid();
	new_folder->user_id = getuid();

	new_folder->number = index;
	new_folder->blocks = 0;

	save_contents();

	return 0;
}

/*
 * myreaddir - 读取目录内容
 *
 * 功能：
 * 1. 读取指定目录下的所有文件和子目录。
 * 2. 使用 FUSE 提供的 filler 函数将目录项添加到缓冲区。
 * 3. 更新目录的访问时间。
 *
 * 参数：
 * - path: 要读取的目录路径。
 * - buffer: 用于存储目录项的缓冲区。
 * - filler: FUSE 提供的回调函数，用于将目录项添加到缓冲区。
 * - offset: 读取偏移量（未使用）。
 * - fi: 文件信息结构（未使用）。
 *
 * 返回值：
 * - 成功时返回 0。
 * - 如果目录不存在，返回 -ENOENT。
 *
 * 实现逻辑：
 * 1. 使用 filler 函数添加 "." 和 ".." 目录项。
 * 2. 根据路径查找对应的目录节点。
 * 3. 如果目录存在，遍历其子节点，使用 filler 函数将每个子节点添加到缓冲区。
 * 4. 更新目录的访问时间。
 *
 * 示例：
 * 假设文件系统结构如下：
 * /
 * ├── home
 * │   └── user
 * └── test.txt
 *
 * 调用示例：
 * 1. myreaddir("/", buffer, filler, 0, fi) -> 缓冲区包含 ["home", "test.txt"]
 * 2. myreaddir("/home", buffer, filler, 0, fi) -> 缓冲区包含 ["user"]
 * 3. myreaddir("/invalid", buffer, filler, 0, fi) -> 返回 -ENOENT
 *
 * 注意：
 * - 每次读取目录时，都会更新目录的访问时间。
 * - 如果目录不存在，返回 -ENOENT。
 */
int myreaddir(const char *path, void *buffer, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi)
{
	printf("READDIR\n");

	filler(buffer, ".", NULL, 0);
	filler(buffer, "..", NULL, 0);

	char *pathname = malloc(strlen(path) + 2);
	strcpy(pathname, path);

	filetype *dir_node = filetype_from_path(pathname);

	if (dir_node == NULL)
	{
		return -ENOENT;
	}
	else
	{
		dir_node->a_time = time(NULL);
		for (int i = 0; i < dir_node->num_children; i++)
		{
			printf(":%s:\n", dir_node->children[i]->name);
			filler(buffer, dir_node->children[i]->name, NULL, 0);
		}
	}

	return 0;
}

/*
 * mygetattr - 获取文件或目录属性
 *
 * 功能：
 * 1. 获取指定路径的文件或目录的属性信息。
 * 2. 将属性信息填充到 stat 结构中。
 * 3. 支持文件和目录的属性查询。
 *
 * 参数：
 * - path: 要查询的文件或目录的完整路径。
 * - statit: 用于存储属性信息的 stat 结构指针。
 *
 * 返回值：
 * - 成功时返回 0。
 * - 如果文件或目录不存在，返回 -ENOENT。
 *
 * 实现逻辑：
 * 1. 根据路径查找对应的文件或目录节点。
 * 2. 如果节点存在，将属性信息填充到 stat 结构中，包括：
 *    - 用户 ID (st_uid)
 *    - 组 ID (st_gid)
 *    - 访问时间 (st_atime)
 *    - 修改时间 (st_mtime)
 *    - 创建时间 (st_ctime)
 *    - 权限模式 (st_mode)
 *    - 硬链接数 (st_nlink)
 *    - 文件大小 (st_size)
 *    - 数据块数 (st_blocks)
 * 3. 如果节点不存在，返回错误码。
 *
 * 示例：
 * 假设文件系统结构如下：
 * /
 * ├── home
 * │   └── user
 * └── test.txt
 *
 * 调用示例：
 * 1. mygetattr("/test.txt", statit) -> 获取 test.txt 文件的属性
 * 2. mygetattr("/home", statit) -> 获取 home 目录的属性
 * 3. mygetattr("/invalid", statit) -> 返回 -ENOENT（文件或目录不存在）
 *
 * 注意：
 * - 必须正确处理文件和目录的属性查询。
 */
static int mygetattr(const char *path, struct stat *statit)
{
	char *pathname;
	pathname = (char *)malloc(strlen(path) + 2);

	strcpy(pathname, path);

	printf("GETATTR %s\n", pathname);

	filetype *file_node = filetype_from_path(pathname);
	if (file_node == NULL)
		return -ENOENT;

	statit->st_uid = file_node->user_id;  // The owner of the file/directory is the user who mounted the filesystem
	statit->st_gid = file_node->group_id; // The group of the file/directory is the same as the group of the user who mounted the filesystem
	statit->st_atime = file_node->a_time; // The last "a"ccess of the file/directory is right now
	statit->st_mtime = file_node->m_time; // The last "m"odification of the file/directory is right now
	statit->st_ctime = file_node->c_time;
	statit->st_mode = file_node->permissions;
	statit->st_nlink = file_node->num_links + file_node->num_children;
	statit->st_size = file_node->size;
	statit->st_blocks = file_node->blocks;

	return 0;
}
/*
 * myrmdir - 删除目录
 *
 * 功能：
 * 1. 删除指定路径的目录。
 * 2. 从父目录的子节点列表中移除该目录。
 * 3. 调用 save_contents 方法将更新后的文件系统保存到磁盘。
 *
 * 参数：
 * - path: 要删除的目录的完整路径。
 *
 * 返回值：
 * - 成功时返回 0。
 * - 如果目录不存在，返回 -ENOENT。
 * - 如果目录非空，返回 -ENOTEMPTY。
 *
 * 实现逻辑：
 * 1. 解析路径，获取目录名称和父目录路径。
 * 2. 在父目录的子节点列表中查找匹配的目录。
 * 3. 如果找到匹配的目录且为空，将其从子节点列表中移除。
 * 4. 调用 save_contents 方法保存文件系统。
 *
 * 示例：
 * 假设文件系统结构如下：
 * /
 * ├── home
 * │   └── user
 * └── test
 *
 * 调用示例：
 * 1. myrmdir("/test") -> 删除 test 目录
 * 2. myrmdir("/home/user") -> 返回 -ENOTEMPTY（user 目录非空）
 * 3. myrmdir("/invalid") -> 返回 -ENOENT（目录不存在）
 *
 * 注意：
 * - 只能删除空目录。
 * - 如果目录非空，操作失败。
 */
int myrmdir(const char *path)
{

	char *pathname = malloc(strlen(path) + 2);
	strcpy(pathname, path);

	char *rindex = strrchr(pathname, '/');

	char *folder_delete = malloc(strlen(rindex + 1) + 2);

	strcpy(folder_delete, rindex + 1);

	*rindex = '\0';

	if (strlen(pathname) == 0)
		strcpy(pathname, "/");

	filetype *parent = filetype_from_path(pathname);

	if (parent == NULL)
		return -ENOENT;

	if (parent->num_children == 0)
		return -ENOENT;

	filetype *curr_child = (parent->children)[0];
	int index = 0;
	while (index < (parent->num_children))
	{
		if (strcmp(curr_child->name, folder_delete) == 0)
		{
			break;
		}
		index++;
		curr_child = (parent->children)[index];
	}

	if (index < (parent->num_children))
	{
		if (((parent->children)[index]->num_children) != 0)
			return -ENOTEMPTY;
		for (int i = index + 1; i < (parent->num_children); i++)
		{
			(parent->children)[i - 1] = (parent->children)[i];
		}
		(parent->num_children) -= 1;
	}

	else
	{
		return -ENOENT;
	}

	save_contents();

	return 0;
}
/*
 * myrm - 删除文件
 *
 * 功能：
 * 1. 删除指定路径的文件。
 * 2. 从父目录的子节点列表中移除该文件。
 * 3. 调用 save_contents 方法将更新后的文件系统保存到磁盘。
 *
 * 参数：
 * - path: 要删除的文件的完整路径。
 *
 * 返回值：
 * - 成功时返回 0。
 * - 如果文件不存在，返回 -ENOENT。
 * - 如果文件是目录且非空，返回 -ENOTEMPTY。
 *
 * 实现逻辑：
 * 1. 解析路径，获取文件名和父目录路径。
 * 2. 在父目录的子节点列表中查找匹配的文件。
 * 3. 如果找到匹配的文件，将其从子节点列表中移除。
 * 4. 调用 save_contents 方法保存文件系统。
 *
 * 示例：
 * 假设文件系统结构如下：
 * /
 * ├── home
 * │   └── user
 * └── test.txt
 *
 * 调用示例：
 * 1. myrm("/test.txt") -> 删除 test.txt 文件
 * 2. myrm("/home/user") -> 返回 -ENOTEMPTY（user 是目录且非空）
 * 3. myrm("/invalid") -> 返回 -ENOENT（文件不存在）
 *
 * 注意：
 * - 只能删除文件，不能删除目录。
 * - 如果文件是目录且非空，操作失败。
 */
int myrm(const char *path)
{

	char *pathname = malloc(strlen(path) + 2);
	strcpy(pathname, path);

	char *rindex = strrchr(pathname, '/');

	char *folder_delete = malloc(strlen(rindex + 1) + 2);

	strcpy(folder_delete, rindex + 1);

	*rindex = '\0';

	if (strlen(pathname) == 0)
		strcpy(pathname, "/");

	filetype *parent = filetype_from_path(pathname);

	if (parent == NULL)
		return -ENOENT;

	if (parent->num_children == 0)
		return -ENOENT;

	filetype *curr_child = (parent->children)[0];
	int index = 0;
	while (index < (parent->num_children))
	{
		if (strcmp(curr_child->name, folder_delete) == 0)
		{
			break;
		}
		index++;
		curr_child = (parent->children)[index];
	}

	if (index < (parent->num_children))
	{
		if (((parent->children)[index]->num_children) != 0)
			return -ENOTEMPTY;
		for (int i = index + 1; i < (parent->num_children); i++)
		{
			(parent->children)[i - 1] = (parent->children)[i];
		}
		(parent->num_children) -= 1;
	}

	else
	{
		return -ENOENT;
	}

	save_contents();

	return 0;
}

/*
 * mycreate - 创建新文件
 *
 * 功能：
 * 1. 在指定路径下创建一个新文件。
 * 2. 分配并初始化新文件的元数据，包括路径、名称、类型、权限、时间戳等。
 * 3. 将新文件添加到父目录的子节点列表中。
 * 4. 调用 save_contents 方法将更新后的文件系统保存到磁盘。
 *
 * 参数：
 * - path: 新文件的完整路径（必须以 "/" 开头）。
 * - mode: 文件的权限模式（未直接使用，固定为 0777）。
 * - fi: 文件信息结构（未使用）。
 *
 * 返回值：
 * - 成功时返回 0。
 * - 如果父目录不存在，返回 -ENOENT。
 *
 * 实现逻辑：
 * 1. 查找一个空闲的 inode 编号。
 * 2. 解析路径，获取新文件的名称和父目录路径。
 * 3. 分配内存并初始化新文件结构（filetype）。
 * 4. 设置新文件的元数据，包括路径、名称、类型、权限、时间戳等。
 * 5. 将新文件添加到父目录的子节点列表中。
 * 6. 调用 save_contents 方法保存文件系统。
 *
 * 示例：
 * 假设文件系统结构如下：
 * /
 * └── home
 *
 * 调用示例：
 * 1. mycreate("/home/test.txt", 0777, fi) -> 在 /home 下创建 test.txt 文件
 *    - 新文件路径: "/home/test.txt"
 *    - 新文件名称: "test.txt"
 *    - 父目录: "/home"
 * 2. mycreate("/invalid/path/file.txt", 0777, fi) -> 返回 -ENOENT（父目录不存在）
 *
 * 注意：
 * - 路径必须以 "/" 开头。
 * - 新文件的权限固定为 0777。
 * - 如果父目录不存在，操作失败。
 */
int mycreate(const char *path, mode_t mode, struct fuse_file_info *fi)
{

	printf("CREATEFILE\n");

	int index = find_free_inode();

	filetype *new_file = malloc(sizeof(filetype));

	char *pathname = malloc(strlen(path) + 2);
	strcpy(pathname, path);

	char *rindex = strrchr(pathname, '/');

	strcpy(new_file->name, rindex + 1);
	strcpy(new_file->path, pathname);

	*rindex = '\0';

	if (strlen(pathname) == 0)
		strcpy(pathname, "/");

	new_file->children = NULL;
	new_file->num_children = 0;
	new_file->parent = filetype_from_path(pathname);
	new_file->num_links = 0;
	new_file->valid = 1;

	if (new_file->parent == NULL)
		return -ENOENT;

	add_child(new_file->parent, new_file);

	// new_file -> type = malloc(10);
	strcpy(new_file->type, "file");

	new_file->c_time = time(NULL);
	new_file->a_time = time(NULL);
	new_file->m_time = time(NULL);
	new_file->b_time = time(NULL);

	new_file->permissions = S_IFREG | 0777;

	new_file->size = 0;
	new_file->group_id = getgid();
	new_file->user_id = getuid();

	new_file->number = index;

	for (int i = 0; i < 16; i++)
	{
		(new_file->datablocks)[i] = find_free_db();
	}

	// new_file -> size = 0;
	new_file->blocks = 0;

	save_contents();

	return 0;
}

/*
 * myopen - 打开文件
 *
 * 功能：
 * 1. 打开指定路径的文件。
 * 2. 检查文件是否存在。
 * 3. 更新文件的访问时间。
 *
 * 参数：
 * - path: 要打开的文件的完整路径。
 * - fi: 文件信息结构（未使用）。
 *
 * 返回值：
 * - 成功时返回 0。
 * - 如果文件不存在，返回 -ENOENT。
 *
 * 实现逻辑：
 * 1. 根据路径查找对应的文件节点。
 * 2. 如果文件存在，更新文件的访问时间。
 * 3. 如果文件不存在，返回错误码。
 *
 * 示例：
 * 假设文件系统结构如下：
 * /
 * └── test.txt
 *
 * 调用示例：
 * 1. myopen("/test.txt", fi) -> 成功打开 test.txt 文件
 * 2. myopen("/invalid.txt", fi) -> 返回 -ENOENT（文件不存在）
 *
 * 注意：
 * - 打开文件时会更新文件的访问时间。
 * - 如果文件不存在，返回 -ENOENT。
 */
int myopen(const char *path, struct fuse_file_info *fi)
{
	printf("OPEN\n");

	char *pathname = malloc(sizeof(path) + 1);
	strcpy(pathname, path);

	filetype *file = filetype_from_path(pathname);

	return 0;
}

/*
 * myread - 读取文件内容
 *
 * 功能：
 * 1. 读取指定文件的内容。
 * 2. 根据文件的大小和数据块分布，从磁盘中读取数据。
 * 3. 将读取的数据存储到提供的缓冲区中。
 * 4. 更新文件的访问时间。
 *
 * 参数：
 * - path: 要读取的文件的完整路径。
 * - buf: 用于存储读取数据的缓冲区。
 * - size: 要读取的数据大小。
 * - offset: 读取的偏移量（未使用）。
 * - fi: 文件信息结构（未使用）。
 *
 * 返回值：
 * - 成功时返回实际读取的字节数。
 * - 如果文件不存在，返回 -ENOENT。
 *
 * 实现逻辑：
 * 1. 根据路径查找对应的文件节点。
 * 2. 如果文件存在，根据文件的大小和数据块分布，从磁盘中读取数据。
 * 3. 将读取的数据存储到提供的缓冲区中。
 * 4. 更新文件的访问时间。
 *
 * 示例：
 * 假设文件系统结构如下：
 * /
 * └── test.txt
 *
 * 调用示例：
 * 1. myread("/test.txt", buf, 1024, 0, fi) -> 读取 test.txt 文件的前 1024 字节
 * 2. myread("/invalid.txt", buf, 1024, 0, fi) -> 返回 -ENOENT（文件不存在）
 *
 * 注意：
 * - 读取数据时会更新文件的访问时间。
 * - 如果文件不存在，返回 -ENOENT。
 */
int myread(const char *path, char *buf, size_t size, off_t offset, struct fuse_file_info *fi)
{

	printf("READ\n");

	char *pathname = malloc(sizeof(path) + 1);
	strcpy(pathname, path);

	filetype *file = filetype_from_path(pathname);
	if (file == NULL)
		return -ENOENT;

	else
	{
		char *str = malloc(sizeof(char) * 1024 * (file->blocks));

		printf(":%ld:\n", file->size);
		strcpy(str, "");
		int i;
		for (i = 0; i < (file->blocks) - 1; i++)
		{
			strncat(str, &spblock.datablocks[block_size * (file->datablocks[i])], 1024);
			printf("--> %s", str);
		}
		strncat(str, &spblock.datablocks[block_size * (file->datablocks[i])], (file->size) % 1024);
		printf("--> %s", str);
		// strncpy(str, &spblock.datablocks[block_size*(file -> datablocks[0])], file->size);
		strcpy(buf, str);
	}
	return file->size;
}

/*
 * myaccess - 检查文件访问权限
 *
 * 功能：
 * 1. 检查指定路径的文件或目录是否可访问。
 * 2. 目前仅作为占位符实现，始终返回成功。
 *
 * 参数：
 * - path: 要检查的文件或目录的完整路径。
 * - mask: 访问权限掩码（未使用）。
 *
 * 返回值：
 * - 始终返回 0，表示成功。
 *
 * 注意：
 * - 当前实现未实际检查权限，需根据需求完善。
 */
int myaccess(const char *path, int mask)
{
	return 0;
}

/*
 * myrename - 重命名文件或目录
 *
 * 功能：
 * 1. 将文件或目录从旧路径重命名为新路径。
 * 2. 更新文件或目录的名称和路径。
 * 3. 调用 save_contents 方法将更新后的文件系统保存到磁盘。
 *
 * 参数：
 * - from: 文件或目录的原始路径。
 * - to: 文件或目录的新路径。
 *
 * 返回值：
 * - 成功时返回 0。
 * - 如果原始路径对应的文件或目录不存在，返回 -ENOENT。
 *
 * 实现逻辑：
 * 1. 解析原始路径，获取文件或目录的节点。
 * 2. 解析新路径，获取新名称和父目录路径。
 * 3. 更新文件或目录的名称和路径。
 * 4. 调用 save_contents 方法保存文件系统。
 *
 * 示例：
 * 假设文件系统结构如下：
 * /
 * ├── home
 * │   └── user
 * └── test.txt
 *
 * 调用示例：
 * 1. myrename("/test.txt", "/home/test.txt") -> 将 test.txt 移动到 /home 目录下
 * 2. myrename("/home/user", "/home/new_user") -> 将 user 目录重命名为 new_user
 * 3. myrename("/invalid", "/new_path") -> 返回 -ENOENT（文件或目录不存在）
 *
 * 注意：
 * - 重命名操作会同时更新文件或目录的名称和路径。
 * - 如果原始路径对应的文件或目录不存在，返回 -ENOENT。
 */
int myrename(const char *from, const char *to)
{
	printf("RENAME: %s\n", from);
	printf("RENAME: %s\n", to);

	char *pathname = malloc(strlen(from) + 2);
	strcpy(pathname, from);

	char *rindex1 = strrchr(pathname, '/');

	filetype *file = filetype_from_path(pathname);

	*rindex1 = '\0';

	char *pathname2 = malloc(strlen(to) + 2);
	strcpy(pathname2, to);

	char *rindex2 = strrchr(pathname2, '/');

	if (file == NULL)
		return -ENOENT;

	// file -> name = realloc(file -> name, strlen(rindex2+1)+2);
	strcpy(file->name, rindex2 + 1);
	// file -> path = realloc(file -> path, strlen(to)+2);
	strcpy(file->path, to);

	printf(":%s:\n", file->name);
	printf(":%s:\n", file->path);

	save_contents();

	return 0;
}

/*
 * mytruncate - 截断文件
 *
 * 功能：
 * 1. 将指定文件截断到指定大小。
 * 2. 目前仅作为占位符实现，未实际实现功能。
 *
 * 参数：
 * - path: 要截断的文件的完整路径。
 * - size: 目标文件大小。
 *
 * 返回值：
 * - 始终返回 0，表示成功。
 *
 * 注意：
 * - 当前实现未实际截断文件，需根据需求完善。
 */
int mytruncate(const char *path, off_t size)
{
	return 0;
}

/*
 * mywrite - 向文件写入数据
 *
 * 功能：
 * 1. 将数据写入指定文件。
 * 2. 根据文件当前大小和数据块使用情况，将数据写入合适的块。
 * 3. 更新文件的大小和块使用情况。
 * 4. 调用 save_contents 方法将更新后的文件系统保存到磁盘。
 *
 * 参数：
 * - path: 要写入的文件的完整路径。
 * - buf: 要写入的数据缓冲区。
 * - size: 要写入的数据大小。
 * - offset: 写入的偏移量（未使用）。
 * - fi: 文件信息结构（未使用）。
 *
 * 返回值：
 * - 成功时返回实际写入的字节数。
 * - 如果文件不存在，返回 -ENOENT。
 *
 * 实现逻辑：
 * 1. 根据路径查找对应的文件节点。
 * 2. 如果文件当前大小为 0，直接将数据写入第一个数据块。
 * 3. 如果文件已有数据，检查最后一个数据块是否有剩余空间：
 *    - 如果有剩余空间，将数据写入剩余空间。
 *    - 如果没有剩余空间，分配新的数据块并写入数据。
 * 4. 更新文件的大小和块使用情况。
 * 5. 调用 save_contents 方法保存文件系统。
 *
 * 示例：
 * 假设文件系统结构如下：
 * /
 * └── test.txt
 *
 * 调用示例：
 * 1. mywrite("/test.txt", "Hello", 5, 0, fi) -> 将 "Hello" 写入 test.txt 文件
 *    - 文件大小更新为 5
 *    - 数据块 0 包含 "Hello"
 * 2. mywrite("/test.txt", " World", 6, 0, fi) -> 将 " World" 追加到 test.txt 文件
 *    - 文件大小更新为 11
 *    - 数据块 0 包含 "Hello World"
 * 3. mywrite("/invalid.txt", "Data", 4, 0, fi) -> 返回 -ENOENT（文件不存在）
 *
 * 注意：
 * - 写入数据时会自动追加到文件末尾。
 * - 如果文件不存在，返回 -ENOENT。
 */
int mywrite(const char *path, const char *buf, size_t size, off_t offset, struct fuse_file_info *fi)
{

	printf("WRITING\n");

	char *pathname = malloc(sizeof(path) + 1);
	strcpy(pathname, path);

	filetype *file = filetype_from_path(pathname);
	if (file == NULL)
		return -ENOENT;

	int indexno = (file->blocks) - 1;

	if (file->size == 0)
	{
		strcpy(&spblock.datablocks[block_size * ((file->datablocks)[0])], buf);
		file->size = strlen(buf);
		(file->blocks)++;
	}
	else
	{
		int currblk = (file->blocks) - 1;
		int len1 = 1024 - (file->size % 1024);
		if (len1 >= strlen(buf))
		{
			strcat(&spblock.datablocks[block_size * ((file->datablocks)[currblk])], buf);
			file->size += strlen(buf);
			printf("---> %s\n", &spblock.datablocks[block_size * ((file->datablocks)[currblk])]);
		}
		else
		{
			char *cpystr = malloc(1024 * sizeof(char));
			strncpy(cpystr, buf, len1 - 1);
			strcat(&spblock.datablocks[block_size * ((file->datablocks)[currblk])], cpystr);
			strcpy(cpystr, buf);
			strcpy(&spblock.datablocks[block_size * ((file->datablocks)[currblk + 1])], (cpystr + len1 - 1));
			file->size += strlen(buf);
			printf("---> %s\n", &spblock.datablocks[block_size * ((file->datablocks)[currblk])]);
			(file->blocks)++;
		}
	}
	save_contents();

	return strlen(buf);
}

static struct fuse_operations operations =
{
    .mkdir = mymkdir,       // 创建目录
    .getattr = mygetattr,   // 获取文件/目录属性
    .readdir = myreaddir,   // 读取目录内容
    .rmdir = myrmdir,       // 删除目录
    .open = myopen,         // 打开文件
    .read = myread,         // 读取文件内容
    .write = mywrite,       // 写入文件内容
    .create = mycreate,     // 创建文件
    .rename = myrename,     // 重命名文件/目录
    .unlink = myrm,         // 删除文件
};

int main(int argc, char *argv[])
{
	// 二进制文件代表了基于磁盘的文件系统（file layout)
	FILE *fd = fopen("file_structure.bin", "rb");
	if (fd)
	{
		printf("LOADING\n");
		// 如果文件存在，读取文件结构数据到 file_array
		fread(&file_array, sizeof(filetype) * 31, 1, fd);

		// 初始化子节点索引
		int child_startindex = 1;
		// 设置根节点的父节点为 NULL
		file_array[0].parent = NULL;

		// 遍历前 6 个节点，在内存中重建文件树结构
		for (int i = 0; i < 6; i++)
		{
			file_array[i].num_children = 0;
			file_array[i].children = NULL;
			// 为每个节点添加子节点
			for (int j = child_startindex; j < child_startindex + 5; j++)
			{
				if (file_array[j].valid)
				{
					add_child(&file_array[i], &file_array[j]);
				}
			}
			child_startindex += 5;
		}

		// 设置根节点
		root = &file_array[0];

		// 打开并读取超级块数据
		FILE *fd1 = fopen("super.bin", "rb");
		fread(&spblock, sizeof(superblock), 1, fd1);
	}
	else
	{
		// 如果文件不存在，初始化超级块和根目录
		initialize_superblock();
		initialize_root_directory();
	}

	// FUSE 库的主入口函数，用于启动文件系统, 指向 fuse_operations 结构体的指针
	return fuse_main(argc, argv, &operations, NULL);
}