BigOS/kernel/fat32.c

/**********************************************************
 *	fat32.c       //added by mingxuan 2019-5-17
 ***********************************************************/

#include "fat32.h"
#include "type.h"
#include "const.h"
#include "protect.h"
#include "string.h"
#include "proc.h"
#include "tty.h"
#include "console.h"
#include "global.h"
#include "proto.h"
#include "fs_const.h"
#include "hd.h"
#include "fs.h"
#include "fs_misc.h"
#include "string.h"
#include "stdio.h"

extern DWORD FAT_END;
extern DWORD TotalSectors;
extern WORD Bytes_Per_Sector;
extern BYTE Sectors_Per_Cluster;
extern WORD Reserved_Sector;
extern DWORD Sectors_Per_FAT;
extern UINT Position_Of_RootDir;
extern UINT Position_Of_FAT1;
extern UINT Position_Of_FAT2;
extern struct file_desc f_desc_table[NR_FILE_DESC];
CHAR VDiskPath[256] = {0};
CHAR cur_path[256] = {0};
u8 *buf;
STATE state;
File f_desc_table_fat[NR_FILE_DESC];

static void load_disk();
static void mkfs_fat();

STATE DeleteDir(const char *dirname)
{
	CHAR fullpath[256] = {0};
	CHAR parent[256] = {0};
	CHAR name[256] = {0};
	DWORD parentCluster = 0, startCluster = 0;
	UINT tag = 0;
	STATE state;

	ToFullPath((PCHAR)dirname, fullpath);
	GetParentFromPath(fullpath, parent);
	GetNameFromPath(fullpath, name);

	state = IsFile(fullpath, &tag);
	if (state != OK)
	{
		return state;
	}
	if (tag == F)
	{
		return WRONGPATH;
	}
	state = PathToCluster(parent, &parentCluster);
	if (state != OK)
	{
		return state;
	}
	state = ClearRecord(parentCluster, name, &startCluster);
	if (state != OK)
	{
		return state;
	}
	DeleteAllRecord(startCluster);
	return OK;
}

STATE CreateDir(const char *dirname)
{
	Record record;
	CHAR fullname[256] = {0};
	CHAR name[256] = {0};
	CHAR parent[256] = {0};
	DWORD parentCluster = 0, startCluster = 0, sectorIndex = 0, off_in_sector = 0;
	STATE state;

	ToFullPath((PCHAR)dirname, fullname);
	GetNameFromPath(fullname, name);
	GetParentFromPath(fullname, parent);
	state = PathToCluster(parent, &parentCluster);
	if (state != OK)
	{
		return state; // 找不到路径
	}
	state = FindSpaceInDir(parentCluster, name, &sectorIndex, &off_in_sector);
	if (state != OK)
	{
		return state; // 虚拟磁盘空间不足
	}
	state = FindClusterForDir(&startCluster);
	if (state != OK)
	{
		return state; // 虚拟磁盘空间不足
	}
	CreateRecord(name, 0x10, startCluster, 0, &record);
	WriteRecord(record, sectorIndex, off_in_sector);
	WriteFAT(1, &startCluster);						   // 写FAT
	CreateRecord(".", 0x10, startCluster, 0, &record); // 准备目录项.的数据
	sectorIndex = Reserved_Sector + 2 * Sectors_Per_FAT + (startCluster - 2) * Sectors_Per_Cluster;
	WriteRecord(record, sectorIndex, 0);				 // 写.目录项
	CreateRecord("..", 0x10, parentCluster, 0, &record); // 准备目录项..的数据
	WriteRecord(record, sectorIndex, sizeof(Record));	 // 写..目录项
	// fflush(fp);
	return OK;
}

STATE OpenDir(const char *dirname)
{
	DWORD parentCluster = 0;
	CHAR fullpath[256] = {0}, parent[256] = {0}, name[256] = {0};
	Record record;
	STATE state;

	if (strcmp(dirname, ".") == 0)
	{
		return OK;
	}
	else if (strcmp(dirname, "..") == 0 || strcmp(dirname, "\\") == 0)
	{
		ChangeCurrentPath((PCHAR)dirname);
		return OK;
	}
	else
	{
		if (IsFullPath((PCHAR)dirname))
		{
			strcpy(fullpath, (PCHAR)dirname);
			GetParentFromPath(fullpath, parent);
			if (strlen(parent) == 0) // 说明dirname是根目录
			{
				memset(cur_path, 0, sizeof(cur_path));
				strcpy(cur_path, fullpath);
				cur_path[strlen(cur_path)] = '\\';
				return OK;
			}
			GetNameFromPath(fullpath, name);
		}
		else
		{
			MakeFullPath(cur_path, (PCHAR)dirname, fullpath);
			strcpy(parent, cur_path);
			strcpy(name, (PCHAR)dirname);
		}
		state = PathToCluster(parent, &parentCluster);
		if (state != OK)
		{
			return state;
		}
		state = ReadRecord(parentCluster, name, &record, NULL, NULL);
		if (state != OK)
		{
			return state;
		}
		if (record.proByte == (BYTE)0x10)
		{
			strcpy(cur_path, fullpath);
			return OK;
		}
		else
		{
			return WRONGPATH;
		}
	}
	return OK;
}

STATE ReadFile(int fd, void *buf, int length)
{
	int size = 0;
	PBYTE sector = NULL;
	DWORD curSectorIndex = 0, nextSectorIndex = 0, off_in_sector = 0, free_in_sector = 0, readsize = 0;
	UINT isLastSector = 0, tag = 0;
	PFile pfile = p_proc_current->task.filp[fd]->fd_node.fd_file;

	if (pfile->flag != R && pfile->flag != RW && pfile->flag != (RW | C)) // modified by mingxuan 2019-5-18
	{
		return ACCESSDENIED;
	}

	kprintf("read:");
	if (pfile->off >= pfile->size)
	{
		return 0;
	}
	sector = (PBYTE)K_PHY2LIN(sys_kmalloc(Bytes_Per_Sector * sizeof(BYTE)));
	if (sector == NULL)
	{
		return SYSERROR;
	}
	GetFileOffset(pfile, &curSectorIndex, &off_in_sector, &isLastSector);
	do
	{
		if (isLastSector) // 当前的扇区是该文件的最后一个扇区
		{
			if (pfile->size % Bytes_Per_Sector == 0)
			{
				free_in_sector = Bytes_Per_Sector - off_in_sector;
			}
			else
			{
				free_in_sector = pfile->size % Bytes_Per_Sector - off_in_sector; // 最后一个扇区的剩余量
			}
			tag = 1; // 置跳出标志
		}
		else
		{
			free_in_sector = Bytes_Per_Sector - off_in_sector; // 本扇区的剩余量
		}
		if (free_in_sector < length - (size)) // 缓冲区装不满
		{
			readsize = free_in_sector;
		}
		else
		{ // 缓冲区能装满
			readsize = length - (size);
			tag = 1; // 置跳出标志
		}
		ReadSector(sector, curSectorIndex);
		memcpy(buf + (size), sector + off_in_sector, readsize);
		(size) += readsize;
		pfile->off += readsize;
		if (tag == 1) // 最后一个扇区或缓冲区装满了
		{
			break;
		}
		else
		{ // 缓冲区还没装满并且还没到最后一个扇区
			GetNextSector(pfile, curSectorIndex, &nextSectorIndex, &isLastSector);
			curSectorIndex = nextSectorIndex;
			off_in_sector = 0;
		}
	} while (1);
	sys_free(sector);
	// pfile->off = 0;
	return size;
}

STATE WriteFile(int fd, const void *buf, int length)
{

	PBYTE sector = NULL;
	DWORD clusterNum = 0;
	DWORD curSectorIndex = 0, nextSectorIndex = 0, off_in_sector = 0, free_in_sector = 0, off_in_buf = 0;
	UINT isLastSector = 0;
	STATE state;
	PFile pfile = p_proc_current->task.filp[fd]->fd_node.fd_file;
	// PFile pfile = &f_desc_table_fat[0];

	// if(pfile->flag!=W) //deleted by mingxuan 2019-5-18
	if (pfile->flag != W && pfile->flag != RW && pfile->flag != (RW | C)) // modified by mingxuan 2019-5-18
	{
		return ACCESSDENIED;
	}

	sector = (PBYTE)K_PHY2LIN(sys_kmalloc(Bytes_Per_Sector * sizeof(BYTE)));
	if (sector == NULL)
	{
		return SYSERROR;
	}
	if (pfile->start == 0) // 此文件是个空文件原来没有分配簇
	{
		state = AllotClustersForEmptyFile(pfile, length); // 空间不足无法分配
		if (state != OK)
		{
			sys_free(sector);
			return state; // 虚拟磁盘空间不足
		}
	}
	else
	{
		if (NeedMoreCluster(pfile, length, &clusterNum))
		{
			state = AddCluster(pfile->start, clusterNum); // 空间不足
			if (state != OK)
			{
				sys_free(sector);
				return state; // 虚拟磁盘空间不足
			}
		}
	}
	GetFileOffset(pfile, &curSectorIndex, &off_in_sector, &isLastSector);
	free_in_sector = Bytes_Per_Sector - off_in_sector;
	while (free_in_sector < length - off_in_buf) // 当前扇区的空闲空间放不下本次要写入的内容
	{
		ReadSector(sector, curSectorIndex);
		memcpy(sector + off_in_sector, (void *)buf + off_in_buf, free_in_sector);
		WriteSector(sector, curSectorIndex);
		off_in_buf += free_in_sector;
		pfile->off += free_in_sector;
		GetNextSector(pfile, curSectorIndex, &nextSectorIndex, &isLastSector);
		curSectorIndex = nextSectorIndex;
		free_in_sector = Bytes_Per_Sector;
		off_in_sector = 0;
	}
	ReadSector(sector, curSectorIndex);
	memcpy(sector + off_in_sector, (void *)buf + off_in_buf, length - off_in_buf);
	WriteSector(sector, curSectorIndex);
	pfile->off += length - off_in_buf;
	sys_free(sector);
	// fflush(fp);
	return OK;
}

STATE CloseFile(int fd)
{
	PFile pfile;
	pfile = p_proc_current->task.filp[fd]->fd_node.fd_file;
	DWORD curSectorIndex = 0, curClusterIndex = 0, nextClusterIndex = 0, parentCluster = 0;
	UINT isLastSector = 0;
	Record record;
	DWORD sectorIndex = 0, off_in_sector = 0;

	// p_proc_current->task.filp_fat[fd] = 0;
	f_desc_table_fat[fd].flag = 0;
	p_proc_current->task.filp[fd]->flag = 0;
	p_proc_current->task.filp[fd] = 0;
	if (pfile->flag == R)
	{
		return OK;
	}
	else
	{
		if (pfile->off < pfile->size)
		{
			GetFileOffset(pfile, &curSectorIndex, NULL, &isLastSector);
			if (isLastSector == 0)
			{
				curSectorIndex = (curClusterIndex - Reserved_Sector - 2 * Sectors_Per_FAT) / Sectors_Per_Cluster + 2;
				GetNextCluster(curClusterIndex, &nextClusterIndex);
				if (nextClusterIndex != FAT_END) // 说明当前簇不是此文件的最后一簇
				{
					WriteFAT(1, &curClusterIndex); // 把当前簇设置为此文件的最后一簇
					ClearFATs(nextClusterIndex);   // 清除此文件的多余簇
				}
			}
		}
		PathToCluster(pfile->parent, &parentCluster);
		ReadRecord(parentCluster, pfile->name, &record, &sectorIndex, &off_in_sector);
		record.highClusterNum = (WORD)(pfile->start >> 16);
		record.lowClusterNum = (WORD)(pfile->start & 0x0000FFFF);
		record.filelength = pfile->off;
		WriteRecord(record, sectorIndex, off_in_sector);
	}
	return OK;
}

STATE OpenFile(const char *filename, int mode)
{

	CHAR fullpath[256] = {0};
	CHAR parent[256] = {0};
	CHAR name[256] = {0};
	Record record;
	DWORD parentCluster;
	STATE state;

	DWORD sectorIndex = 0, off_in_sector = 0; // added by mingxuan 2019-5-19

	ToFullPath((PCHAR)filename, fullpath);
	GetParentFromPath(fullpath, parent);
	GetNameFromPath(fullpath, name);

	state = PathToCluster(parent, &parentCluster);
	kprintf("\nstate=");
	kprintf("%d", state);
	if (state != OK)
	{
		return -1;
	}

	// added by mingxuan 2019-5-19
	state = FindSpaceInDir(parentCluster, name, &sectorIndex, &off_in_sector); // 检测文件名是否存在
	if (mode & O_CREAT)														   // 如果用户使用了O_CREAT
	{
		if (state == NAMEEXIST) // 文件存在，使用O_CREAT是多余的，继续执行OpenFile即可
		{
			kprintf("file exists, O_CREAT is no use!");
		}
		else // 文件不存在，需要使用O_CREAT，先创建文件，再执行OpenFile
		{
			CreateRecord(name, 0x20, 0, 0, &record);
			WriteRecord(record, sectorIndex, off_in_sector); // 写目录项
		}
	}
	else // 用户没有使用O_CREAT
	{
		if (state != NAMEEXIST) // 文件不存在，需要使用O_CREAT，用户没有使用，则报错并返回-1，表示路径有误
		{
			kprintf("no file, use O_CREAT!");
			return -1;
		}
		else
		{
		} // 文件存在，使用O_CREAT是多余的，继续执行OpenFile即可
	}
	//~mingxuan 2019-5-19

	state = ReadRecord(parentCluster, name, &record, NULL, NULL);
	kprintf("state=");
	kprintf("%d", state);
	if (state != OK)
	{
		kprintf("ReadRecord Fail!");
		return -1;
	}

	int i;
	int fd = -1;
	for (i = 3; i < NR_FILES; i++)
	{
		if (p_proc_current->task.filp[i] == 0)
		{
			fd = i;
			break;
		}
	}

	if ((fd < 0) || (fd >= NR_FILES))
	{
		// panic("filp[] is full (PID:%d)", proc2pid(p_proc_current));
		kprintf("filp[] is full (PID:");
		kprintf("%d", (int)proc2pid(p_proc_current));
		kprintf(")\n");
		return -1;
	}

	// 找一个未用的文件描述符
	for (i = 0; i < NR_FILE_DESC; i++)
		if ((f_desc_table[i].flag == 0))
			break;
	if (i >= NR_FILE_DESC)
	{
		kprintf("f_desc_table[] is full (PID:");
		kprintf("%d", (int)proc2pid(p_proc_current));
		kprintf(")\n");
		return -1;
	}

	p_proc_current->task.filp[fd] = &f_desc_table[i];
	f_desc_table[i].flag = 1;

	// 找一个未用的FILE
	for (i = 0; i < NR_FILE_DESC; i++)
		if (f_desc_table_fat[i].flag == 0)
			break;
	if (i >= NR_FILE_DESC)
	{
		kprintf("f_desc_table[] is full (PID:");
		kprintf("%d", (int)proc2pid(p_proc_current));
		kprintf(")\n");
	}

	// 以下是给File结构体赋值
	memset(f_desc_table_fat[i].parent, 0, sizeof(f_desc_table_fat[i].parent)); // 初始化parent字段
	memset(f_desc_table_fat[i].name, 0, sizeof(f_desc_table_fat[i].name));	   // 初始化name字段
	strcpy(f_desc_table_fat[i].parent, parent);
	strcpy(f_desc_table_fat[i].name, name);
	f_desc_table_fat[i].start = (record.highClusterNum << 16) + record.lowClusterNum;
	f_desc_table_fat[i].off = 0;
	f_desc_table_fat[i].size = record.filelength;
	f_desc_table_fat[i].flag = mode;
	// kprintf("flag:");
	// deint(f_desc_table_fat[i].flag);
	// kprintf("index:");
	// deint(i);
	p_proc_current->task.filp[fd]->fd_node.fd_file = &f_desc_table_fat[i];

	return fd;
}

STATE CreateFile(const char *filename)
{
	Record record;
	CHAR fullpath[256] = {0};
	CHAR parent[256] = {0};
	CHAR name[256] = {0};
	DWORD parentCluster = 0, sectorIndex = 0, off_in_sector = 0;
	STATE state;

	ToFullPath((PCHAR)filename, fullpath);
	GetParentFromPath(fullpath, parent);
	GetNameFromPath((PCHAR)filename, name);
	state = PathToCluster(parent, &parentCluster);
	if (state != OK)
	{
		return state; // 找不到路径
	}

	state = FindSpaceInDir(parentCluster, name, &sectorIndex, &off_in_sector);
	if (state != OK)
	{
		return state;
	}

	CreateRecord(name, 0x20, 0, 0, &record);
	WriteRecord(record, sectorIndex, off_in_sector); // 写目录项
	return OK;
}

STATE DeleteFile(const char *filename)
{
	CHAR fullpath[256] = {0};
	CHAR parent[256] = {0};
	CHAR name[256] = {0};
	DWORD parentCluster = 0;
	DWORD startCluster = 0;
	UINT tag = 0;
	STATE state;

	ToFullPath((PCHAR)filename, fullpath);
	GetParentFromPath(fullpath, parent);
	GetNameFromPath(fullpath, name);

	state = IsFile(fullpath, &tag);
	if (state != OK)
	{
		return state;
	}
	if (tag == D)
	{
		return WRONGPATH;
	}
	state = PathToCluster(parent, &parentCluster);
	if (state != OK)
	{
		return state;
	}
	state = ClearRecord(parentCluster, name, &startCluster);
	if (state != OK)
	{
		return state;
	}
	if (startCluster != 0)
	{
		ClearFATs(startCluster);
	}
	return OK;
}

STATE IsFile(PCHAR path, PUINT tag)
{
	CHAR fullpath[256] = {0};
	CHAR parent[256] = {0};
	CHAR name[256] = {0};
	DWORD parentCluster = 0;
	Record record;
	STATE state;

	ToFullPath(path, fullpath);
	GetParentFromPath(fullpath, parent);
	GetNameFromPath(fullpath, name);
	state = PathToCluster(parent, &parentCluster);
	if (state != OK)
	{
		return state; // 找不到路径
	}
	state = ReadRecord(parentCluster, name, &record, NULL, NULL);
	if (state != OK)
	{
		return state; // 找不到路径
	}
	if (record.proByte == 0x10)
	{
		*tag = D;
	}
	else
	{
		*tag = F;
	}
	return OK;
}

void init_fs_fat()
{
	kprintf("Initializing fat32 file system...  \n");

	buf = (u8 *)K_PHY2LIN(sys_kmalloc(FSBUF_SIZE));

	int fat32_dev = get_fs_dev(PRIMARY_MASTER, FAT32_TYPE); // added by mingxuan 2020-10-27

	// load_disk(FAT_DEV);	// deleted by mingxuan 2020-10-27
	load_disk(fat32_dev); // modified by mingxuan 2020-10-27
	if (TotalSectors == 0)
	{
		mkfs_fat();
		// load_disk(FAT_DEV);	//deleted by mingxuan 2020-10-27
		load_disk(fat32_dev); // modified by mingxuan 2020-10-27
	}
	int i;
	for (i = 0; i < NR_FILE_DESC; ++i)
	{
		f_desc_table_fat[i].flag = 0;
	}
}

static void load_disk(int dev)
{
	MESSAGE driver_msg;
	PCHAR cur = "V:\\";

	driver_msg.type = DEV_READ;
	driver_msg.DEVICE = MINOR(dev);
	driver_msg.POSITION = SECTOR_SIZE * 1;
	driver_msg.BUF = buf;
	driver_msg.CNT = SECTOR_SIZE;
	driver_msg.PROC_NR = proc2pid(p_proc_current); /// TASK_A

	hd_rdwt(&driver_msg);

	memcpy(&Bytes_Per_Sector, buf + 11, 2);
	memcpy(&Sectors_Per_Cluster, buf + 13, 1);
	memcpy(&Reserved_Sector, buf + 14, 2);
	memcpy(&TotalSectors, buf + 32, 4);
	memcpy(&Sectors_Per_FAT, buf + 36, 4);
	Position_Of_RootDir = (Reserved_Sector + Sectors_Per_FAT * 2) * Bytes_Per_Sector;
	Position_Of_FAT1 = Reserved_Sector * Bytes_Per_Sector;
	Position_Of_FAT2 = (Reserved_Sector + Sectors_Per_FAT) * Bytes_Per_Sector;
	strcpy(cur_path, cur);
}

static void mkfs_fat()
{
	MESSAGE driver_msg;

	int fat32_dev = get_fs_dev(PRIMARY_MASTER, FAT32_TYPE); // added by mingxuan 2020-10-27

	/* get the geometry of ROOTDEV */
	struct part_info geo;
	driver_msg.type = DEV_IOCTL;
	// driver_msg.DEVICE	= MINOR(FAT_DEV);	//deleted by mingxuan 2020-10-27
	driver_msg.DEVICE = MINOR(fat32_dev); // modified by mingxuan 2020-10-27

	driver_msg.REQUEST = DIOCTL_GET_GEO;
	driver_msg.BUF = &geo;
	driver_msg.PROC_NR = proc2pid(p_proc_current);
	hd_ioctl(&driver_msg);

	kprintf("dev size: ");
	kprintf("%d", geo.size);
	kprintf(" sectors\n");

	TotalSectors = geo.size;

	DWORD jump = 0x009058eb;				 // 跳转指令：占3个字节
	DWORD oem[2] = {0x4f44534d, 0x302e3553}; // 厂商标志，OS版本号:占8个字节
	// 以下是BPB的内容
	WORD bytes_per_sector = 512;  // 每扇区字节数：占2个字节
	WORD sectors_per_cluster = 8; // 每簇扇区数：占1个字节
	WORD reserved_sector = 32;	  // 保留扇区数：占2个字节
	WORD number_of_FAT = 2;		  // FAT数：占1个字节
	BYTE mediaDescriptor = 0xF8;
	DWORD sectors_per_FAT = (TotalSectors * 512 - 8192) / 525312 + 1; // 每FAT所占扇区数，用此公式可以算出来：占4个字节
	DWORD root_cluster_number = 2;									  // 根目录簇号：占4个字节
	// 以下是扩展BPB内容
	CHAR volumeLabel[11] = {'N', 'O', ' ', 'N', 'A', 'M', 'E', ' ', ' ', ' ', ' '}; // 卷标：占11个字节
	CHAR systemID[8] = {'F', 'A', 'T', '3', '2', ' ', ' ', ' '};					// 系统ID，FAT32系统中一般取为“FAT32”：占8个字节
	// 以下是有效结束标志
	DWORD end = 0xaa55;

	DWORD media_descriptor[2] = {0x0ffffff8, 0xffffffff}; // FAT介质描述符
	DWORD cluster_tag = 0x0fffffff;						  // 文件簇的结束单元标记

	Record vLabel; // 卷标的记录项。
	// DWORD clearSize=sectors_per_cluster*bytes_per_sector-sizeof(Record);
	char volumelabel[3] = "MZY";

	memcpy(buf, &jump, 3);	 // 写入跳转指令:占3个字节(其实没有用)
	memcpy(buf + 3, oem, 8); // 厂商标志，OS版本号:占8个字节
	// 以下是写 BPB
	memcpy(buf + 11, &bytes_per_sector, 2);	   // 每扇区字节数：占2个字节
	memcpy(buf + 13, &sectors_per_cluster, 1); // 写入每簇扇区数：占1个字节
	memcpy(buf + 14, &reserved_sector, 2);	   // 写入保留扇区数：占2个字节
	memcpy(buf + 16, &number_of_FAT, 1);	   // 写入FAT数：占1个字节
	memcpy(buf + 21, &mediaDescriptor, 1);	   // 写入媒体描述符
	memcpy(buf + 32, &TotalSectors, 4);		   // 写入总扇区数
	memcpy(buf + 36, &sectors_per_FAT, 4);	   // 写入每FAT所占扇区数：占4个字节
	memcpy(buf + 44, &root_cluster_number, 4); // 写入根目录簇号：占4个字节
	// 以下是写 扩展BPB
	memcpy(buf + 71, volumeLabel, 11); // 写卷标：占11个字节
	memcpy(buf + 82, systemID, 8);	   // 系统ID，FAT32系统中一般取为“FAT32”：占8个字节
	// 由于引导代码对于本虚拟系统没有用，故省略
	memcpy(buf + 510, &end, 2);
	// WR_SECT_FAT(buf, 1);			//deleted by mingxuan 2020-10-27
	WR_SECT_FAT(fat32_dev, buf, 1); // modified by mingxuan 2020-10-27

	// 初始化FAT
	memset(buf, 0, SECTOR_SIZE); // 写介质描述单元
	memcpy(buf, media_descriptor, 8);
	memcpy(buf + 8, &cluster_tag, 4); // 写根目录的簇号
	// WR_SECT_FAT(buf, reserved_sector);	// deleted by mingxuan 2020-10-27
	WR_SECT_FAT(fat32_dev, buf, reserved_sector); // modified by mingxuan 2020-10-27

	// 初始化根目录
	CreateRecord(volumelabel, 0x08, 0, 0, &vLabel); // 准备卷标的目录项的数据
	memset(buf, 0, SECTOR_SIZE);					// 将准备好的记录项数据写入虚拟硬盘
	memcpy(buf, &vLabel, sizeof(Record));
	// WR_SECT_FAT(buf, reserved_sector+2*sectors_per_FAT);	// deleted by mingxuan 2020-10-27
	WR_SECT_FAT(fat32_dev, buf, reserved_sector + 2 * sectors_per_FAT); // modified by mingxuan 2020-10-27
}

int rw_sector_fat(int io_type, int dev, u64 pos, int bytes, int proc_nr, void *buf)
{
	MESSAGE driver_msg;

	driver_msg.type = io_type;
	driver_msg.DEVICE = MINOR(dev);
	driver_msg.POSITION = pos;
	driver_msg.CNT = bytes; /// hu is: 512
	driver_msg.PROC_NR = proc_nr;
	driver_msg.BUF = buf;

	hd_rdwt(&driver_msg);
	return 0;
}

int rw_sector_sched_fat(int io_type, int dev, int pos, int bytes, int proc_nr, void *buf)
{
	MESSAGE driver_msg;

	driver_msg.type = io_type;
	driver_msg.DEVICE = MINOR(dev);
	driver_msg.POSITION = pos;
	driver_msg.CNT = bytes; /// hu is: 512
	driver_msg.PROC_NR = proc_nr;
	driver_msg.BUF = buf;

	hd_rdwt_sched(&driver_msg);
	return 0;
}

int sys_CreateFile(void *uesp)
{
	state = CreateFile((PCHAR)(void *)get_arg(uesp, 1));
	if (state == OK)
	{
		kprintf("           create file success");
	}
	else
	{
		DisErrorInfo(state);
	}

	return state;
}

int sys_DeleteFile(void *uesp)
{
	state = DeleteFile((PCHAR)(void *)get_arg(uesp, 1));
	if (state == OK)
	{
		kprintf("           delete file success");
	}
	else
	{
		DisErrorInfo(state);
	}
	return state;
}

int sys_OpenFile(void *uesp)
{
	/*	// state=OpenFile(get_arg(uesp, 1),
		// 				get_arg(uesp, 2));
		// if(state==OK)
		// {
		// 	kprintf("open file success");
		// }
		// else {
		// 	DisErrorInfo(state);
		// }
		// return state;
		state=OpenFile(get_arg(uesp, 1),
						get_arg(uesp, 2));
		kprintf("           open file success");
		return state;	*/
	return 0;
}

int sys_CloseFile(void *uesp)
{
	state = CloseFile(get_arg(uesp, 1));
	if (state == OK)
	{
		kprintf("           close file success");
	}
	else
	{
		DisErrorInfo(state);
	}
	return state;
}

int sys_WriteFile(void *uesp)
{
	state = WriteFile(get_arg(uesp, 1),
					  (BYTE *)(void *)get_arg(uesp, 2),
					  get_arg(uesp, 3));
	if (state == OK)
	{
		kprintf("           write file success");
	}
	else
	{
		DisErrorInfo(state);
	}
	return state;
}

int sys_ReadFile(void *uesp)
{
	// state=ReadFile(get_arg(uesp, 1),
	// 				get_arg(uesp, 2),
	// 				get_arg(uesp, 3),
	// 				get_arg(uesp, 4));
	// if(state==OK)
	// {
	// 	//debug("read file success");
	// 	debug("           read file success");
	// }
	// else {
	// 	DisErrorInfo(state);
	// }
	// return state;
	return 0;
}

int sys_OpenDir(void *uesp)
{
	// state=OpenDir(get_arg(uesp, 1));
	// if(state==OK)
	// {
	// 	//debug("open dir success");
	// 	debug("           open dir success");
	// }
	// else {
	// 	DisErrorInfo(state);
	// }
	// return state;
	return 0;
}

int sys_CreateDir(void *uesp)
{
	// state=CreateDir(get_arg(uesp, 1));
	// if(state==OK)
	// {
	// 	//debug("create dir success");
	// 	debug("           create dir success");
	// }
	// else {
	// 	DisErrorInfo(state);
	// }
	// return state;
	return 0;
}

int sys_DeleteDir(void *uesp)
{
	// state=DeleteDir(get_arg(uesp, 1));
	// if(state==OK)
	// {
	// 	debug("delete dir success");
	// 	debug("           delete dir success");
	// }
	// else {
	// 	DisErrorInfo(state);
	// }
	// return state;
	return 0;
}

int sys_ListDir(void *uesp)
{

	// DArray *array=NULL;
	// char *s = get_arg(uesp, 1);
	// CHAR temp[256]={0};
	// UINT tag=0;

	// array = InitDArray(10, 10);
	// memset(temp, 0, sizeof(temp));
	// if (strlen(s) != 0)
	// {
	// 	strcpy(temp,s);
	// 	if(IsFile(temp,&tag))
	// 	{
	// 		if(tag==1)
	// 		{
	// 			printf("不是目录的路径\n\n");
	// 		}
	// 	}
	// }
	// else {
	// 	GetCurrentPath(temp);
	// }
	// state=ListAll(temp, array);
	// if(state==OK)
	// {
	// 	DirCheckup(array);
	// }else {
	// 	DisErrorInfo(state);
	// 	kprintf("\n");
	// }
	// DestroyDArray(array);
	return 0;
}

void DisErrorInfo(STATE state)
{
	if (state == SYSERROR)
	{
		kprintf("          system error\n");
	}
	else if (state == VDISKERROR)
	{
		kprintf("          disk error\n");
	}
	else if (state == INSUFFICIENTSPACE)
	{
		kprintf("          no much space\n");
	}
	else if (state == WRONGPATH)
	{
		kprintf("          path error\n");
	}
	else if (state == NAMEEXIST)
	{
		kprintf("          name exists\n");
	}
	else if (state == ACCESSDENIED)
	{
		kprintf("          deny access\n");
	}
	else
	{
		kprintf("          unknown error\n");
	}
}