CoolPotOS/fs/fat.c

#include "../include/fat.h"
#include "../include/vdisk.h"
#include "../include/memory.h"
#include "../include/vfs.h"
#include "../include/printf.h"
#include "../include/cmos.h"

#define get_dm(vfs) ((fat_cache *)(vfs->cache))->dm
#define get_now_dir(vfs) ((fat_cache *)(vfs->cache))->dir
#define get_clustno(high, low) (high << 16) | (low & 0xffff)
#define clustno_end(type) 0xfffffff & ((((1 << (type - 1)) - 1) << 1) + 1)

static inline int get_fat_date(unsigned short year, unsigned short month,
                               unsigned short day) {
    year -= 1980;
    unsigned short date = 0;
    date |= (year & 0x7f) << 9;
    date |= (month & 0x0f) << 5;
    date |= (day & 0x1f);
    return date;
}
static inline int get_fat_time(unsigned short hour, unsigned short minute) {
    unsigned short time = 0;
    time |= (hour & 0x1f) << 11;
    time |= (minute & 0x3f) << 5;
    return time;
}
void read_fat(unsigned char *img, int *fat, unsigned char *ff, int max,
              int type) {
    if (type == 12) {
        for (int i = 0, j = 0; i < max; i += 2) {
            fat[i + 0] = (img[j + 0] | img[j + 1] << 8) & 0xfff;
            fat[i + 1] = (img[j + 1] >> 4 | img[j + 2] << 4) & 0xfff;
            j += 3;
        }
        // 保留簇
        ff[0] = true;
        ff[1] = true;
        for (int i = 1; i < max; i++) {
            if (fat[i] > 0 && fat[i] < 0xff0) {
                ff[fat[i]] = true;
            } else if (fat[i] >= 0xff0 && fat[i] <= 0xfff) {
                ff[i + 1] = true;
            }
        }
    } else if (type == 16) {
        unsigned short *p = (unsigned short *)img;
        for (int i = 0; i != max; i++) {
            fat[i] = p[i];
        }
        ff[0] = true;
        ff[1] = true;
        for (int i = 1; i < max; i++) {
            if (fat[i] > 0 && fat[i] < 0xfff0) {
                ff[fat[i]] = true;
            } else if (fat[i] >= 0xfff0 && fat[i] <= 0xffff) {
                ff[i + 1] = true;
            }
        }
    } else if (type == 32) {
        unsigned int *p = (unsigned int *)img;
        for (int i = 0; i != max; i++) {
            fat[i] = p[i];
        }
        ff[0] = true;
        ff[1] = true;
        for (int i = 1; i < max; i++) {
            if (fat[i] > 0 && fat[i] < 0xffffff0) {
                ff[fat[i]] = true;
            } else if (fat[i] >= 0xffffff0 && fat[i] <= 0xfffffff) {
                ff[i + 1] = true;
            }
        }
    }
    return;
}
int get_directory_max(struct FAT_FILEINFO *directory, vfs_t *vfs) {
    if (directory == get_dm(vfs).root_directory) {
        return get_dm(vfs).RootMaxFiles;
    }
    for (int i = 1; FindForCount(i, get_dm(vfs).directory_list) != NULL; i++) {
        struct List *l = FindForCount(i, get_dm(vfs).directory_list);
        if ((struct FAT_FILEINFO *)l->val == directory) {
            return (int)FindForCount(i, get_dm(vfs).directory_max_list)->val;
        }
    }
}
void file_loadfile(int clustno, int size, char *buf, int *fat, vfs_t *vfs) {
    if (!size) {
        return;
    }
    int s =
            ((size - 1) / get_dm(vfs).ClustnoBytes + 1) * get_dm(vfs).ClustnoBytes;
    void *img = kmalloc(s);
    int flag = 0, a, num = 0, sec_start = 0;
    for (int i = 0; i != (size - 1) / get_dm(vfs).ClustnoBytes + 1; i++) {
        uint32_t sec = (get_dm(vfs).FileDataAddress +
                        (clustno - 2) * get_dm(vfs).ClustnoBytes) /
                       get_dm(vfs).SectorBytes;
        if (!flag) {
            a = sec;
            num = 1;
        } else {
            if (a + num == sec) {
                num++;
            } else {
                Disk_Read(a, num * get_dm(vfs).ClustnoBytes / get_dm(vfs).SectorBytes,
                          img + sec_start * get_dm(vfs).ClustnoBytes, vfs->disk_number);
                sec_start += num;
                a = sec;
                num = 1;
                clustno = fat[clustno];
                continue;
            }
        }
        // Disk_Read(sec, get_dm(vfs).ClustnoBytes / get_dm(vfs).SectorBytes,
        //           img + i * get_dm(vfs).ClustnoBytes, vfs->disk_number);
        flag = 1;
        clustno = fat[clustno];
    }
    if (num) {
        Disk_Read(a, num * get_dm(vfs).ClustnoBytes / get_dm(vfs).SectorBytes,
                  img + sec_start * get_dm(vfs).ClustnoBytes, vfs->disk_number);
    }
    memcpy((void *)buf, img, size);
    kfree(img);
    return;
}
void file_savefile(int clustno, int size, char *buf, int *fat,
                   unsigned char *ff, vfs_t *vfs) {
    uint32_t clustall = 0;
    int tmp = clustno;
    int end = clustno_end(get_dm(vfs).type);
    while (fat[clustno] != end) { // 计算文件占多少Fat项 Fat项 = 大小 / 簇大小 + 1
        clustno = fat[clustno];
        clustall++;
    }
    int old_clustno = clustno;
    clustno = tmp;
    int alloc_size;
    if (size >
        (clustall + 1) *
        get_dm(vfs).ClustnoBytes) { // 新大小 > (旧大小 / 簇大小 + 1) * 簇大小
        // 请求内存大小 = (新大小 / 簇大小 + 1) * 簇大小
        alloc_size =
                ((size - 1) / get_dm(vfs).ClustnoBytes + 1) * get_dm(vfs).ClustnoBytes;
        // 分配Fat（这里需要在写盘前分配）
        for (int size1 = size; size1 > ((clustall + 1) * get_dm(vfs).ClustnoBytes);
             size1 -= get_dm(vfs).ClustnoBytes) {
            for (int i = 0; i != get_dm(vfs).FatMaxTerms; i++) {
                if (!ff[i]) {
                    fat[old_clustno] = i;
                    old_clustno = i;
                    ff[i] = true;
                    break;
                }
            }
        }
        fat[old_clustno] = end; // 结尾Fat
        ff[old_clustno] = true;
    } else if (size <=
               (clustall + 1) *
               get_dm(vfs).ClustnoBytes) { // 新大小 <= (旧大小 / 簇大小
        // + 1) * 簇大小
        // 请求内存大小 = (旧大小 / 簇大小 + 1) * 簇大小
        alloc_size = (clustall + 1) * get_dm(vfs).ClustnoBytes;
        // 这里不分配Fat的原因是要清空更改后多余的数据
    }
    void *img = kmalloc(alloc_size);
    memclean((char *)img, alloc_size);
    memcpy(img, buf, size); // 把要写入的数据复制到新请求的内存地址
    // for (int i = 0; i != (alloc_size / get_dm(vfs).ClustnoBytes); i++) {
    //   uint32_t sec = (get_dm(vfs).FileDataAddress +
    //                   (clustno - 2) * get_dm(vfs).ClustnoBytes) /
    //                  get_dm(vfs).SectorBytes;
    //   Disk_Write(sec, get_dm(vfs).ClustnoBytes / get_dm(vfs).SectorBytes,
    //              img + i * get_dm(vfs).ClustnoBytes, vfs->disk_number);
    //   clustno = fat[clustno];
    // }
    int flag = 0, a, num = 0, sec_start = 0;
    for (int i = 0; i != (alloc_size / get_dm(vfs).ClustnoBytes); i++) {
        uint32_t sec = (get_dm(vfs).FileDataAddress +
                        (clustno - 2) * get_dm(vfs).ClustnoBytes) /
                       get_dm(vfs).SectorBytes;
        if (!flag) {
            a = sec;
            num = 1;
        } else {
            if (a + num == sec) {
                num++;
            } else {
                Disk_Write(a, num * get_dm(vfs).ClustnoBytes / get_dm(vfs).SectorBytes,
                           img + sec_start * get_dm(vfs).ClustnoBytes,
                           vfs->disk_number);
                sec_start += num;
                a = sec;
                num = 1;
                clustno = fat[clustno];
                continue;
            }
        }
        // Disk_Read(sec, get_dm(vfs).ClustnoBytes / get_dm(vfs).SectorBytes,
        //           img + i * get_dm(vfs).ClustnoBytes, vfs->disk_number);
        flag = 1;
        clustno = fat[clustno];
    }
    if (num) {
        Disk_Write(a, num * get_dm(vfs).ClustnoBytes / get_dm(vfs).SectorBytes,
                   img + sec_start * get_dm(vfs).ClustnoBytes, vfs->disk_number);
    }
    kfree(img);
    if (size <
        clustall *
        get_dm(vfs).ClustnoBytes) { // 新大小 < (旧大小 / 簇大小) * 簇大小
        // 分配Fat（中间情况没必要分配）
        int i = old_clustno;
        for (int size1 = clustall * get_dm(vfs).ClustnoBytes; size1 > size;
             size1 -= get_dm(vfs).ClustnoBytes) {
            fat[i] = 0;
            ff[i] = false;
            for (int j = 0; j != get_dm(vfs).FatMaxTerms; j++) {
                if (fat[j] == i) {
                    i = j;
                }
            }
        }
        old_clustno = i;
        fat[old_clustno] = end;
        ff[old_clustno] = true;
    }
    file_savefat(fat, 0, get_dm(vfs).FatMaxTerms, vfs);
}
void file_saveinfo(struct FAT_FILEINFO *directory, vfs_t *vfs) {
    if (directory == get_dm(vfs).root_directory) {
        Disk_Write(get_dm(vfs).RootDictAddress / get_dm(vfs).SectorBytes,
                   get_dm(vfs).RootMaxFiles * 32 / get_dm(vfs).SectorBytes,
                   (void *)directory, vfs->disk_number);
    } else {
        for (int i = 1; FindForCount(i, get_dm(vfs).directory_list) != NULL; i++) {
            struct List *list = FindForCount(i, get_dm(vfs).directory_list);
            if (list->val == directory) {
                list = FindForCount(i, get_dm(vfs).directory_clustno_list);
                int k = (int)FindForCount(i, get_dm(vfs).directory_max_list)->val * 32 /
                        get_dm(vfs).ClustnoBytes;
                for (int j = list->val, l = 0; l != k; l++) {
                    Disk_Write((get_dm(vfs).FileDataAddress +
                                (j - 2) * get_dm(vfs).ClustnoBytes) /
                               get_dm(vfs).SectorBytes,
                               get_dm(vfs).ClustnoBytes / get_dm(vfs).SectorBytes,
                               (char *)directory + l * get_dm(vfs).SectorBytes,
                               vfs->disk_number);
                    j = get_dm(vfs).fat[j];
                }
                break;
            }
        }
    }
}
void file_savefat(int *fat, int clustno, int length, vfs_t *vfs) {
    unsigned char *img = get_dm(vfs).ADR_DISKIMG + get_dm(vfs).Fat1Address;
    int size, sec;
    if (get_dm(vfs).type == 12) {
        for (int i = 0; i <= length; i++) {
            if ((clustno + i) % 2 == 0) {
                img[(clustno + i) * 3 / 2 + 0] = fat[clustno + i] & 0xff;
                img[(clustno + i) * 3 / 2 + 1] =
                        (fat[clustno + i] >> 8 | (img[(clustno + i) * 3 / 2 + 1] & 0xf0)) &
                        0xff;
            } else if ((clustno + i) % 2 != 0) {
                img[(clustno + i - 1) * 3 / 2 + 1] =
                        ((img[(clustno + i - 1) * 3 / 2 + 1] & 0x0f) | fat[clustno + i]
                                << 4) &
                        0xff;
                img[(clustno + i - 1) * 3 / 2 + 2] = (fat[clustno + i] >> 4) & 0xff;
            }
        }
        size = length * 3 / 2 - 1;
        sec = clustno * 3 / 2;
    } else if (get_dm(vfs).type == 16) {
        for (int i = 0; i <= length; i++) {
            img[(clustno + i) * 2 + 0] = fat[clustno + i] & 0xff;
            img[(clustno + i) * 2 + 1] = (fat[clustno + i] >> 8) & 0xff;
        }
        size = length * 2 - 1;
        sec = clustno * 2;
    } else if (get_dm(vfs).type == 32) {
        for (int i = 0; i <= length; i++) {
            img[(clustno + i) * 4 + 0] = fat[clustno + i] & 0xff;
            img[(clustno + i) * 4 + 1] = (fat[clustno + i] >> 8) & 0xff;
            img[(clustno + i) * 4 + 2] = (fat[clustno + i] >> 16) & 0xff;
            img[(clustno + i) * 4 + 3] = fat[clustno + i] >> 24;
        }
        size = length * 4 - 1;
        sec = clustno * 4;
    }
    Disk_Write((get_dm(vfs).Fat1Address + sec) / get_dm(vfs).SectorBytes,
               size / get_dm(vfs).SectorBytes + 1,
               get_dm(vfs).ADR_DISKIMG + get_dm(vfs).Fat1Address,
               vfs->disk_number);
    Disk_Write((get_dm(vfs).Fat2Address + sec) / get_dm(vfs).SectorBytes,
               size / get_dm(vfs).SectorBytes + 1,
               get_dm(vfs).ADR_DISKIMG + get_dm(vfs).Fat2Address,
               vfs->disk_number);
}
struct FAT_FILEINFO *file_search(char *name, struct FAT_FILEINFO *finfo,
                                 int max) {
    int i, j;
    char s[12];
    for (j = 0; j < 11; j++) {
        s[j] = ' ';
    }
    j = 0;
    for (i = 0; name[i] != 0; i++) {
        if (j >= 11) {
            return 0; /*没有找到*/
        }
        if (name[i] == '.' && j <= 8) {
            j = 8;
        } else {
            s[j] = name[i];
            if ('a' <= s[j] && s[j] <= 'z') {
                /*将小写字母转换为大写字母*/
                s[j] -= 0x20;
            }
            j++;
        }
    }
    for (i = 0; i < max;) {
        if (finfo[i].name[0] == 0x00) {
            break;
        }
        if ((finfo[i].type & 0x18) == 0) {
            for (j = 0; j < 11; j++) {
                if (finfo[i].name[j] != s[j]) {
                    goto next;
                }
            }
            return finfo + i; /*找到文件*/
        }
        next:
        i++;
    }
    return 0; /*没有找到*/
}
struct FAT_FILEINFO *dict_search(char *name, struct FAT_FILEINFO *finfo,
                                 int max) {
    int i, j;
    char s[12];
    for (j = 0; j < 11; j++) {
        s[j] = ' ';
    }
    j = 0;
    for (i = 0; name[i] != 0; i++) {
        if (j >= 11) {
            return 0; /*没有找到*/
        } else {
            s[j] = name[i];
            if ('a' <= s[j] && s[j] <= 'z') {
                /*将小写字母转换为大写字母*/
                s[j] -= 0x20;
            }
            j++;
        }
    }
    for (i = 0; i < max;) {
        if (finfo[i].name[0] == 0x00) {
            break;
        }
        if (finfo[i].type == 0x10) {
            for (j = 0; j < 11; j++) {
                if (finfo[i].name[j] != s[j]) {
                    goto next;
                }
            }
            return finfo + i; /* 找到文件 */
        }
        next:
        i++;
    }
    return 0; /*没有找到*/
}
struct FAT_FILEINFO *Get_File_Address(char *path1, vfs_t *vfs) {
    // TODO: Modifly it
    struct FAT_FILEINFO *bmpDict = get_now_dir(vfs);
    int drive_number = vfs->disk_number;
    char *path = (char *)kmalloc(strlen(path1) + 1);
    char *bmp = path;
    strcpy(path, path1);
    strtoupper(path);
    if (strncmp("/", path, 1) == 0) {
        path += 1;
        bmpDict = get_dm(vfs).root_directory;
    }
    if (path[0] == '\\' || path[0] == '/') {
        // 跳过反斜杠和正斜杠
        for (int i = 0; i < strlen(path); i++) {
            if (path[i] != '\\' && path[i] != '/') {
                path += i;
                break;
            }
        }
    }
    char *temp_name = (char *)kmalloc(128);
    memclean(temp_name,128);
    struct FAT_FILEINFO *finfo = get_dm(vfs).root_directory;
    int i = 0;
    while (1) {
        int j;
        for (j = 0; i < strlen(path); i++, j++) {
            if (path[i] == '\\' || path[i] == '/') {
                temp_name[j] = '\0';
                i++;
                break;
            }
            temp_name[j] = path[i];
        }
        finfo = dict_search(temp_name, bmpDict, get_directory_max(bmpDict, vfs));

        if (finfo == 0) {
            if (path[i] != '\0') {
                kfree((void *)temp_name);
                kfree((void *)bmp);
                return 0;
            }
            finfo = file_search(temp_name, bmpDict, get_directory_max(bmpDict, vfs));
            if (finfo == 0) {
                kfree((void *)temp_name);
                kfree((void *)bmp);
                return 0;
            } else {
                goto END;
            }
        } else {
            if (get_clustno(finfo->clustno_high, finfo->clustno_low) != 0) {
                for (int count = 1;
                     FindForCount(count, get_dm(vfs).directory_clustno_list) != NULL;
                     count++) {
                    struct List *list =
                            FindForCount(count, get_dm(vfs).directory_clustno_list);
                    if (get_clustno(finfo->clustno_high, finfo->clustno_low) ==
                                                                             list->val) {
                        list = FindForCount(count, get_dm(vfs).directory_list);
                        bmpDict = (struct FAT_FILEINFO *)list->val;
                        break;
                    }
                }
            } else {
                bmpDict = get_dm(vfs).root_directory;
            }
            memclean(temp_name, 128);
        }
    }
    END:
    kfree((void *)temp_name);
    kfree((void *)bmp);
    return finfo;
}
struct FAT_FILEINFO *Get_dictaddr(char *path1, vfs_t *vfs) {
    // TODO: Modifly it
    struct FAT_FILEINFO *bmpDict = get_now_dir(vfs);
    int drive_number = vfs->disk_number;
    char *path = (char *)kmalloc(strlen(path1) + 1);
    char *bmp = path;
    strcpy(path, path1);
    strtoupper(path);
    if (strncmp("/", path, 1) == 0) {
        path += 1;
        bmpDict = get_dm(vfs).root_directory;
    }
    if (path[0] == '\\' || path[0] == '/') {
        // 跳过反斜杠和正斜杠
        for (int i = 0; i < strlen(path); i++) {
            if (path[i] != '\\' && path[i] != '/') {
                path += i;
                break;
            }
        }
    }
    char *temp_name = (char *)kmalloc(128);
    struct FAT_FILEINFO *finfo;
    int i = 0;
    while (1) {
        int j;
        for (j = 0; i < strlen(path); i++, j++) {
            if (path[i] == '\\' || path[i] == '/') {
                temp_name[j] = '\0';
                i++;
                break;
            }
            temp_name[j] = path[i];
        }
        finfo = dict_search(temp_name, bmpDict, get_directory_max(bmpDict, vfs));

        if (finfo == 0) {
            if (path[i] != 0) {
                bmpDict = NULL;
            }
            goto END;
        } else {
            if (get_clustno(finfo->clustno_high, finfo->clustno_low) != 0) {
                for (int count = 1;
                     FindForCount(count, get_dm(vfs).directory_clustno_list) != NULL;
                     count++) {
                    struct List *list =
                            FindForCount(count, get_dm(vfs).directory_clustno_list);
                    if (get_clustno(finfo->clustno_high, finfo->clustno_low) ==
                                                                             list->val) {
                        list = FindForCount(count, get_dm(vfs).directory_list);
                        bmpDict = (struct FAT_FILEINFO *)list->val;
                        break;
                    }
                }
            } else {
                bmpDict = get_dm(vfs).root_directory;
            }
            memclean(temp_name, 128);
            if (path[i] == '\0') {
                goto END;
            }
        }
    }
    END:
    kfree((void *)temp_name);
    kfree(((void *)bmp));
    return bmpDict;
}
int mkdir(char *dictname, int last_clust, vfs_t *vfs) {
    /*
            dictname:目录名
            last_clust:上一级目录的簇号
    */

    struct FAT_FILEINFO *check_info = dict_search(
            dictname, get_now_dir(vfs), get_directory_max(get_now_dir(vfs), vfs));
    if(check_info != 0) return 0;

    int r = mkfile(dictname, vfs);
    if (!r)
        return 0;
    // 三个目录项（模板）
    static struct FAT_FILEINFO model[3];
    // .目录项，指向自己
    // ..目录项，指向上一级目录
    // 空目录项（为mkfile函数提供指引）
    model[0].reserve = 0;
    model[1].reserve = 0;
    model[2].reserve = 0;
    memcpy(model[2].name, "NULL       ", 11);
    model[2].type = 0x20; // 文件的type属性是0x20
    // 将size date time这类属性全部设置为0
    model[2].size = 0;
    model[2].update_date =
            get_fat_date(get_year(), get_mon(), get_day_of_month());
    model[2].update_time = get_fat_time(get_hour(), get_min());
    for (int i = 0; i != get_dm(vfs).FatMaxTerms; i++) {
        if (!get_dm(vfs).fat[i]) {
            model[2].clustno_low = i;
            int end = clustno_end(get_dm(vfs).type);
            get_dm(vfs).fat[i] = end;
            get_dm(vfs).FatClustnoFlags[i] = true;
            break;
        }
    }
    model[0].name[0] = '.';
    for (int i = 1; i != 8; i++) {
        model[0].name[i] = ' ';
    }
    for (int i = 0; i != 3; i++) {
        model[0].ext[i] = ' ';
    }
    struct FAT_FILEINFO *finfo1 = Get_File_Address(dictname, vfs);
    model[0].type = 0x10;
    model[0].clustno_low = finfo1->clustno_low; // 指向自己
    model[0].clustno_high = finfo1->clustno_high;
    model[0].size = 0;
    model[0].update_date =
            get_fat_date(get_year(), get_mon(), get_day_of_month());
    model[0].update_time = get_fat_time(get_hour(), get_min());
    model[1].name[0] = '.';
    model[1].name[1] = '.';
    for (int i = 2; i != 8; i++) {
        model[1].name[i] = ' ';
    }
    for (int i = 0; i != 3; i++) {
        model[1].ext[i] = ' ';
    }
    model[1].clustno_low = last_clust;
    model[1].size = 0;
    model[1].update_date =
            get_fat_date(get_year(), get_mon(), get_day_of_month());
    model[1].update_time = get_fat_time(get_hour(), get_min());
    model[1].type = 0x10;

    Fat_WriteFile(vfs, dictname, (char *)&model[0], 32 * 3);
    struct FAT_FILEINFO *finfo = Get_File_Address(dictname, vfs);

    finfo->type = 0x10; // 是目录（文件夹的type属性是0x10）
    finfo->size = 0;
    int drive_number = vfs->disk_number;
    AddVal(get_clustno(finfo->clustno_high, finfo->clustno_low),
           get_dm(vfs).directory_clustno_list);
    if (last_clust == 0) {
        file_saveinfo(get_dm(vfs).root_directory, vfs);
    } else {
        for (int i = 1; FindForCount(i, get_dm(vfs).directory_clustno_list) != NULL;
             i++) {
            struct List *list = FindForCount(i, get_dm(vfs).directory_clustno_list);
            if (list->val == last_clust) {
                list = FindForCount(i, get_dm(vfs).directory_list);
                struct FAT_FILEINFO *d_finfo = (struct FAT_FILEINFO *)list->val;
                file_saveinfo(d_finfo, vfs);
            }
        }
    }
    file_savefat(get_dm(vfs).fat,
                 get_clustno(model[2].clustno_high, model[2].clustno_low), 1,
                 vfs);

    void *directory_alloc = kmalloc(get_dm(vfs).ClustnoBytes);
    Disk_Read((get_dm(vfs).FileDataAddress +
               (get_clustno(finfo->clustno_high, finfo->clustno_low) - 2) *
               get_dm(vfs).ClustnoBytes) /
              get_dm(vfs).SectorBytes,
              get_dm(vfs).ClustnoBytes / get_dm(vfs).SectorBytes, directory_alloc,
              vfs->disk_number);

    AddVal(directory_alloc, get_dm(vfs).directory_list);
    AddVal(get_dm(vfs).ClustnoBytes / 32, get_dm(vfs).directory_max_list);

    return 1;
}

struct FAT_FILEINFO *clust_sech(int clustno, struct FAT_FILEINFO *finfo,
                                int max) {
    // 通过簇号找到文件信息
    int i, j;
    j = 0;
    for (i = 0; i < max; i++) {
        if (finfo[i].clustno_low == clustno) {
            return finfo + i;
        }
    }
    return 0; /*没找到*/
}
int del(char *cmdline, vfs_t *vfs) {
    // 删除某个文件
    char *name = cmdline;
    int i;
    struct FAT_FILEINFO *finfo;
    finfo = Get_File_Address(name, vfs);
    if (finfo == 0 || finfo->type == 0x01 || finfo->type == 0x04) {
        return 0;
    }
    file_savefile(get_clustno(finfo->clustno_high, finfo->clustno_low), 0, NULL,
                  get_dm(vfs).fat, get_dm(vfs).FatClustnoFlags, vfs);
    finfo->name[0] = 0xe5;
    get_dm(vfs).fat[get_clustno(finfo->clustno_high, finfo->clustno_low)] = 0;
    get_dm(vfs)
            .FatClustnoFlags[get_clustno(finfo->clustno_high, finfo->clustno_low)] =
            false;
    file_saveinfo(Get_dictaddr(name, vfs), vfs);
    file_savefat(get_dm(vfs).fat,
                 get_clustno(finfo->clustno_high, finfo->clustno_low), 1, vfs);
    return 1;
}
int deldir(char *path, vfs_t *vfs) {
    struct FAT_FILEINFO *finfo = Get_dictaddr(path, vfs);
    if (finfo == Get_dictaddr(".", vfs)) {
        return 0;
    }
    struct FAT_FILEINFO *f = get_now_dir(vfs);
    get_now_dir(vfs) = finfo;
    for (int i = 2; finfo[i].name[0] != '\0'; i++) {
        if (finfo[i].type == 0x10 && finfo[i].name[0] != 0xe5) {
            char s[30];
            int j = 0;
            for (; finfo[i].name[j] != ' '; j++) {
                s[j] = finfo[i].name[j];
            }
            s[j] = '\0';
            // printk("(CALL)DEL DIR:%s\n", s);
            if (deldir(s, vfs) == -1) {
                return 0;
            }
            // return -1;
        }
    }
    for (int i = 2; finfo[i].name[0] != '\0'; i++) {
        if (finfo[i].name[0] != 0xe5 && finfo[i].type != 0x10) {
            char s[30];
            int p = 0;
            for (int j = 0; finfo[i].name[j] != ' '; j++, p++) {
                s[p] = finfo[i].name[j];
            }
            if (finfo[i].ext[0] != ' ') {
                s[p++] = '.';
                for (int j = 0; finfo[i].ext[j] != ' ' || j != 3; j++, p++) {
                    s[p] = finfo[i].ext[j];
                }
            }
            s[p] = '\0';
            // printk("(IN)DEL FILE:%s\n", s);
            if (del(s, vfs) == -1) {
                return 0;
            }
        }
    }
    get_now_dir(vfs) = f;
    // printk("(IN)DEL SELF\n");
    struct FAT_FILEINFO *root_finfo;
    if (finfo[1].clustno_low == 0) {
        root_finfo = get_dm(vfs).root_directory;
    } else {
        for (int i = 1; FindForCount(i, get_dm(vfs).directory_clustno_list) != NULL;
             i++) {
            if (FindForCount(i, get_dm(vfs).directory_clustno_list)->val ==
                finfo[1].clustno_low) {
                root_finfo =
                        (struct FAT_FILEINFO *)FindForCount(i, get_dm(vfs).directory_list)
                                ->val;
                // printk("FIND ROOT %08x\n", root_finfo);
            }
        }
    }
    for (int i = 0; root_finfo[i].name[0] != '\0'; i++) {
        // printk("ROOT FILE:%s\n", root_finfo[i].name);
        if (root_finfo[i].clustno_low == finfo[0].clustno_low) {
            root_finfo[i].name[0] = 0xe5;
            break;
        }
    }
    get_dm(vfs).fat[get_clustno(finfo->clustno_high, finfo->clustno_low)] = 0;
    get_dm(vfs)
            .FatClustnoFlags[get_clustno(finfo->clustno_high, finfo->clustno_low)] =
            false;
    file_saveinfo(Get_dictaddr(path, vfs), vfs);
    file_savefat(get_dm(vfs).fat,
                 get_clustno(finfo->clustno_high, finfo->clustno_low), 1, vfs);
    return 1;
}
int mkfile(char *name, vfs_t *vfs) {
//    logk("mkfile : %s\n", name);
    char s[12];
    int i, j;

    struct FAT_FILEINFO *finfo = Get_dictaddr(name, vfs);
 //   logk("finfo = %08x\n", finfo);
    if (finfo == NULL) {
        return 0;
    }
    int max = get_directory_max(finfo, vfs);

    char *path = name;
    for (i = strlen(name); i >= 0; i--) {
        if (name[i] == '/' || name[i] == '\\') {
            name += i + 1;
            break;
        }
    }

    for (j = 0; j != 12; j++) {
        s[j] = ' ';
    }
    j = 0;
    for (i = 0; name[i] != 0; i++) {
        if (j >= 11) {
            return;
        }
        if (name[i] == '.' && j <= 8) {
            j = 8;
        } else {
            s[j] = name[i];
            if ('a' <= s[j] && s[j] <= 'z') {
                s[j] -= 0x20;
            }
            j++;
        }
    }
    for (i = 0;; i++) {
        if (finfo[i].name[0] == 0x00 || finfo[i].name[0] == 0xe5) {
            finfo = finfo + i;
            break;
        }
        if (i >= max && finfo != get_dm(vfs).root_directory) {
            for (int j = 1; FindForCount(j, get_dm(vfs).directory_list) != NULL;
                 j++) {
                struct List *l = FindForCount(j, get_dm(vfs).directory_list);
                if ((struct FAT_FILEINFO *)l->val == finfo) {
                    max += get_dm(vfs).ClustnoBytes / 32;
                    FindForCount(j, get_dm(vfs).directory_max_list)->val = max;
                    struct FAT_FILEINFO *finfo_ =
                            (struct FAT_FILEINFO *)realloc((void *)finfo, max * 32);
                    if (get_now_dir(vfs) == finfo) {
                        get_now_dir(vfs) = finfo_;
                    }
                    finfo = finfo_;
                    l->val = finfo;
                    break;
                }
            }
            int end = clustno_end(get_dm(vfs).type), last;
            for (int j = get_clustno(finfo->clustno_high, finfo->clustno_low);;
                 j = get_dm(vfs).fat[j]) {
                if (get_dm(vfs).fat[j] == end) {
                    last = j;
                    break;
                }
            }
            for (int j = 0; j != get_dm(vfs).FatMaxTerms; j++) {
                if (!get_dm(vfs).fat[j]) {
                    get_dm(vfs).fat[last] = j;
                    get_dm(vfs).fat[j] = end;
                    get_dm(vfs).FatClustnoFlags[j] = true;
                    break;
                }
            }
            i--;
        }
    }
    for (i = 0; i != 8; i++) {
        finfo->name[i] = s[i];
    }
    for (i = 8; i != 11; i++) {
        finfo->ext[i - 8] = s[i];
    }
    finfo->type = 0x20;
    for (int i = 0; i != get_dm(vfs).FatMaxTerms; i++) {
        if (!get_dm(vfs).fat[i]) {
            finfo->clustno_low = i & 0xffff;
            finfo->clustno_high = i >> 16;
            int end = clustno_end(get_dm(vfs).type);
            get_dm(vfs).fat[i] = end;
            get_dm(vfs).FatClustnoFlags[i] = true;
            break;
        }
    }
    finfo->reserve = 0;
    finfo->update_time = get_fat_time(get_hour(), get_min());
    finfo->update_date =
            get_fat_date(get_year(), get_mon(), get_day_of_month());
    finfo->size = 0;
    file_saveinfo(Get_dictaddr(path, vfs), vfs);
    file_savefat(get_dm(vfs).fat,
                 get_clustno(finfo->clustno_high, finfo->clustno_low), 1, vfs);
    return 1;
}
int changedict(char *dictname, vfs_t *vfs) {
    // cd命令的依赖函数
    strtoupper(dictname);
    if (strcmp(dictname, "/") == 0) {
        while (vfs->path->ctl->all != 0) {
            kfree((FindForCount(vfs->path->ctl->all, vfs->path)->val));
            DeleteVal(vfs->path->ctl->all, vfs->path);
        }
        get_now_dir(vfs) = get_dm(vfs).root_directory;
        return 1;
    }
    struct FAT_FILEINFO *finfo = dict_search(
            dictname, get_now_dir(vfs), get_directory_max(get_now_dir(vfs), vfs));
    // 找文件夹
    if (finfo == 0) {
        // 没找到
        return 0;
    }
    if (get_clustno(finfo->clustno_high, finfo->clustno_low) == 0) {
        // 根目录
        while (vfs->path->ctl->all != 0) {
            kfree((FindForCount(vfs->path->ctl->all, vfs->path)->val));
            DeleteVal(vfs->path->ctl->all, vfs->path);
        }
        get_now_dir(vfs) = get_dm(vfs).root_directory;
        return 1;
    }
    //..进行特殊的处理
    //.不进行处理
    // 其他按照下面的方式处理
    if (strcmp(dictname, "..") != 0 && strcmp(dictname, ".") != 0) {
        char *dict = kmalloc(255);
        strcpy(dict, dictname);
        AddVal(dict, vfs->path);
    }

    if (strcmp(dictname, "..") == 0) {
        kfree((FindForCount(vfs->path->ctl->all, vfs->path)->val));
        DeleteVal(vfs->path->ctl->all, vfs->path);
    }
    for (int count = 1;
         FindForCount(count, get_dm(vfs).directory_clustno_list) != NULL;
         count++) {
        struct List *list = FindForCount(count, get_dm(vfs).directory_clustno_list);
        if (get_clustno(finfo->clustno_high, finfo->clustno_low) == list->val) {
            list = FindForCount(count, get_dm(vfs).directory_list);
            get_now_dir(vfs) = (struct FAT_FILEINFO *)list->val;
            break;
        }
    }
    return 1;
}
int rename(char *src_name, char *dst_name, vfs_t *vfs) {
    strtoupper(src_name);
    strtoupper(dst_name);
    char name[9], ext[4];
    int i;
    memclean(name, 9);
    memclean(ext, 4);
    for (i = 0; dst_name[i] != '.'; i++) {
        name[i] = dst_name[i];
    }
    i++;
    for (int j = 0; i != strlen(dst_name); i++, j++) {
        ext[j] = dst_name[i];
    }
    struct FAT_FILEINFO *finfo = Get_File_Address(src_name, vfs);
    if (finfo == 0 || finfo->type == 0x01 || finfo->type == 0x04) {
        return 0;
    }
    memset((void *)finfo->name, ' ', 11);
    for (i = 0; i != strlen(name); i++) {
        finfo->name[i] = name[i];
    }
    for (i = 0; i != strlen(ext); i++) {
        finfo->ext[i] = ext[i];
    }
    file_saveinfo(Get_dictaddr(src_name, vfs), vfs);
    return 1;
}
int format(char drive) {

}
int attrib(char *filename, ftype type, struct vfs_t *vfs) {
    struct FAT_FILEINFO *finfo = Get_File_Address(filename, vfs);
    if (finfo == 0) {
        return 0;
    }
    if (type == FLE)
        finfo->type = 0x20;
    else if (type == RDO)
        finfo->type = 0x01;
    else if (type == HID)
        finfo->type = 0x02;
    else if (type == SYS)
        finfo->type = 0x04;
    else
        return 0;
    file_saveinfo(Get_dictaddr(filename, vfs), vfs);
    return 1;
}
void fat_InitFS(struct vfs_t *vfs, uint8_t disk_number) {
    vfs->cache = kmalloc(sizeof(fat_cache));
    void *boot_sector = kmalloc(512);
    Disk_Read(0, 1, boot_sector, disk_number);

    if (memcmp(boot_sector + BS_FileSysType, "FAT12   ", 8) == 0) {
        get_dm(vfs).type = 12;
    } else if (memcmp(boot_sector + BS_FileSysType, "FAT16   ", 8) == 0) {
        get_dm(vfs).type = 16;
    } else if (memcmp(boot_sector + BS_FileSysType + BPB_Fat32ExtByts, "FAT32   ",
                      8) == 0) {
        get_dm(vfs).type = 32;
    }
    get_dm(vfs).SectorBytes = *(unsigned short *)(boot_sector + BPB_BytsPerSec);
    get_dm(vfs).RootMaxFiles = *(unsigned short *)(boot_sector + BPB_RootEntCnt);
    get_dm(vfs).ClustnoBytes = get_dm(vfs).SectorBytes *
                               *(unsigned char *)(boot_sector + BPB_SecPerClus);
    get_dm(vfs).Fat1Address = *(unsigned short *)(boot_sector + BPB_RsvdSecCnt) *
                              get_dm(vfs).SectorBytes;
    if (get_dm(vfs).type != 32) {
        get_dm(vfs).RootDictAddress =
                (*(unsigned char *)(boot_sector + BPB_NumFATs) *
                 *(unsigned short *)(boot_sector + BPB_FATSz16) +
                 *(unsigned short *)(boot_sector + BPB_RsvdSecCnt)) *
                get_dm(vfs).SectorBytes;
        get_dm(vfs).FileDataAddress =
                get_dm(vfs).RootDictAddress + get_dm(vfs).RootMaxFiles * 32;
        if (*(unsigned short *)(boot_sector + BPB_TotSec16) != 0) {
            get_dm(vfs).imgTotalSize =
                    *(unsigned short *)(boot_sector + BPB_TotSec16) *
                    get_dm(vfs).SectorBytes;
        } else {
            get_dm(vfs).imgTotalSize = *(unsigned int *)(boot_sector + BPB_TotSec32) *
                                       get_dm(vfs).SectorBytes;
        }
        get_dm(vfs).Fat2Address = get_dm(vfs).Fat1Address +
                                  *(unsigned short *)(boot_sector + BPB_FATSz16) *
                                  get_dm(vfs).SectorBytes;
    } else {
        get_dm(vfs).FileDataAddress =
                (*(unsigned char *)(boot_sector + BPB_NumFATs) *
                 *(unsigned int *)(boot_sector + BPB_FATSz32) +
                 *(unsigned short *)(boot_sector + BPB_RsvdSecCnt)) *
                get_dm(vfs).SectorBytes;
        get_dm(vfs).RootDictAddress =
                get_dm(vfs).FileDataAddress +
                (*(unsigned int *)(boot_sector + BPB_RootClus) - 2) *
                get_dm(vfs).ClustnoBytes;
        get_dm(vfs).imgTotalSize =
                *(unsigned int *)(boot_sector + BPB_TotSec32) * get_dm(vfs).SectorBytes;
        get_dm(vfs).Fat2Address =
                get_dm(vfs).Fat1Address +
                *(unsigned int *)(boot_sector + BPB_FATSz32) * get_dm(vfs).SectorBytes;
        get_dm(vfs).RootMaxFiles = get_dm(vfs).ClustnoBytes / 32;
    }
    get_dm(vfs).FatMaxTerms =
            (get_dm(vfs).Fat2Address - get_dm(vfs).Fat1Address) * 8 /
            get_dm(vfs).type;

    uint32_t sec = (get_dm(vfs).RootDictAddress + get_dm(vfs).RootMaxFiles * 32) /
                   get_dm(vfs).SectorBytes;
    get_dm(vfs).ADR_DISKIMG = (unsigned int)kmalloc(get_dm(vfs).RootDictAddress +
                                                   get_dm(vfs).RootMaxFiles * 32);
    Disk_Read(0, sec, (void *)get_dm(vfs).ADR_DISKIMG, disk_number);


    get_dm(vfs).fat = kmalloc(get_dm(vfs).FatMaxTerms * sizeof(int));
    get_dm(vfs).FatClustnoFlags = kmalloc(get_dm(vfs).FatMaxTerms * sizeof(char));
    read_fat((unsigned char *)(get_dm(vfs).ADR_DISKIMG +
                               (unsigned int)get_dm(vfs).Fat1Address),
             get_dm(vfs).fat, get_dm(vfs).FatClustnoFlags,
             get_dm(vfs).FatMaxTerms, get_dm(vfs).type);
    get_dm(vfs).root_directory =
            (struct FAT_FILEINFO *)kmalloc(get_dm(vfs).RootMaxFiles * 32);
    memcpy((void *)get_dm(vfs).root_directory,
           (void *)get_dm(vfs).ADR_DISKIMG + get_dm(vfs).RootDictAddress,
           get_dm(vfs).RootMaxFiles * 32);
    get_dm(vfs).directory_list = (struct List *)NewList();
    get_dm(vfs).directory_clustno_list = (struct List *)NewList();
    get_dm(vfs).directory_max_list = (struct List *)NewList();
    struct FAT_FILEINFO *finfo = get_dm(vfs).root_directory;

    for (int i = 0; i != get_dm(vfs).RootMaxFiles; i++) {
        if (finfo[i].type == 0x10 && finfo[i].name[0] != 0xe5) {
            AddVal(get_clustno(finfo[i].clustno_high, finfo[i].clustno_low),
                   (struct List *)get_dm(vfs).directory_clustno_list);
            int end = clustno_end(get_dm(vfs).type), k = 1;
            for (int j = get_clustno(finfo[i].clustno_high, finfo[i].clustno_low);
                 get_dm(vfs).fat[j] != end; j = get_dm(vfs).fat[j], k++)
                ;
            void *directory_alloc = kmalloc(k * get_dm(vfs).ClustnoBytes);
            for (int j = get_clustno(finfo[i].clustno_high, finfo[i].clustno_low),
                         l = 0;
                 l != k; l++) {
                uint32_t sec1 =
                        (get_dm(vfs).FileDataAddress + (j - 2) * get_dm(vfs).ClustnoBytes) /
                        get_dm(vfs).SectorBytes;
                Disk_Read(sec1, get_dm(vfs).ClustnoBytes / get_dm(vfs).SectorBytes,
                          (char *)directory_alloc + l * get_dm(vfs).SectorBytes,
                          disk_number);
                j = get_dm(vfs).fat[j];
            }
            AddVal((int)directory_alloc, (struct List *)get_dm(vfs).directory_list);
            AddVal(k * get_dm(vfs).ClustnoBytes / 32,
                   (struct List *)get_dm(vfs).directory_max_list);
        }
        if (finfo[i].name[0] == 0) {
            break;
        }
    }

    for (int i = 1;
         FindForCount(i, (struct List *)get_dm(vfs).directory_list) != NULL;
         i++) {
        struct List *list =
                FindForCount(i, (struct List *)get_dm(vfs).directory_list);
        finfo = (struct FAT_FILEINFO *)list->val;
        for (int j = 0; j != get_directory_max(finfo, vfs); j++) {
            if (finfo[j].type == 0x10 && finfo[j].name[0] != 0xe5 &&
                strncmp(".", (char *)finfo[j].name, 1) != 0 &&
                strncmp("..", (char *)finfo[j].name, 2) != 0) {
                AddVal(get_clustno(finfo[j].clustno_high, finfo[j].clustno_low),
                       (struct List *)get_dm(vfs).directory_clustno_list);
                int end = clustno_end(get_dm(vfs).type), k = 1;
                for (int m = get_clustno(finfo[j].clustno_high, finfo[j].clustno_low);
                     get_dm(vfs).fat[m] != end; m = get_dm(vfs).fat[m], k++)
                    ;
                void *directory_alloc = kmalloc(k * get_dm(vfs).ClustnoBytes);
                for (int m = get_clustno(finfo[j].clustno_high, finfo[j].clustno_low),
                             l = 0;
                     l != k; l++) {
                    uint32_t sec1 = (get_dm(vfs).FileDataAddress +
                                     (m - 2) * get_dm(vfs).ClustnoBytes) /
                                    get_dm(vfs).SectorBytes;
                    Disk_Read(sec1, get_dm(vfs).ClustnoBytes / get_dm(vfs).SectorBytes,
                              (char *)directory_alloc + l * get_dm(vfs).SectorBytes,
                              disk_number);
                    m = get_dm(vfs).fat[m];
                }
                AddVal((int)directory_alloc, (struct List *)get_dm(vfs).directory_list);
                AddVal(k * get_dm(vfs).ClustnoBytes / 32,
                       (struct List *)get_dm(vfs).directory_max_list);
            }
            if (finfo[j].name[0] == 0) {
                break;
            }
        }
    }
    kfree((boot_sector));
}
void Fat_CopyCache(struct vfs_t *dest, struct vfs_t *src) {
    dest->cache = kmalloc(sizeof(fat_cache));
    memcpy(dest->cache, src->cache, sizeof(fat_cache));
}
bool Fat_cd(struct vfs_t *vfs, char *dictName) {
    return changedict(dictName, vfs);
}
bool Fat_ReadFile(struct vfs_t *vfs, char *path, char *buffer) {
    struct FAT_FILEINFO *finfo;
    finfo = Get_File_Address(path, vfs);
    if (finfo == 0) {
        return 0;
    } else {
        file_loadfile(get_clustno(finfo->clustno_high, finfo->clustno_low),
                      finfo->size, buffer, get_dm(vfs).fat, vfs);
        return 1;
    }
}
bool Fat_WriteFile(struct vfs_t *vfs, char *path, char *buffer, int size) {
    struct FAT_FILEINFO *finfo = Get_File_Address(path, vfs);
    file_savefile(get_clustno(finfo->clustno_high, finfo->clustno_low), size,
                  buffer, get_dm(vfs).fat, get_dm(vfs).FatClustnoFlags, vfs);
    finfo->size = size;
    file_saveinfo(Get_dictaddr(path, vfs), vfs);
}
List *Fat_ListFile(struct vfs_t *vfs, char *dictpath) {
    struct FAT_FILEINFO *finfo = Get_dictaddr(dictpath, vfs);
    if(finfo == NULL) {
        return NULL;
    }
    List *result = NewList();
    char s[30];
    for (int i = 0; i != 30; i++) {
        s[i] = 0;
    }
    for (int i = 0; i < get_directory_max(finfo, vfs); i++) {
        if (finfo[i].name[0] == 0x00) {
            break;
        }
        if (finfo[i].name[0] != 0xe5) {
            if ((finfo[i].type & 0x18) == 0 || finfo[i].type == 0x10) {
                for (int j = 0; j < 8; j++) {
                    s[j] = finfo[i].name[j];
                }
                s[8] = '.';
                if (finfo[i].ext[0] == ' ') {
                    s[8] = 0;
                } else {
                    s[9] = finfo[i].ext[0];
                    s[10] = finfo[i].ext[1];
                    s[11] = finfo[i].ext[2];
                }
                if (s[0] != '+') {
                    vfs_file *d = kmalloc(sizeof(vfs_file));
                    if (finfo[i].type == 0x10) {
                        d->type = DIR;
                    } else if (finfo[i].type == 0x20) {
                        d->type = FLE;
                    } else if (finfo[i].type == 0x01) {
                        d->type = RDO;
                    } else if (finfo[i].type == 0x02) {
                        d->type = HID;
                    } else if (finfo[i].type == 0x04) {
                        d->type = SYS;
                    }
                    d->year = (finfo[i].update_date & 65024) >> 9;
                    d->year += 1980;
                    d->month = (finfo[i].update_date & 480) >> 5;
                    d->day = finfo[i].update_date & 31;
                    d->hour = (finfo[i].update_time & 63488) >> 11;
                    d->minute = (finfo[i].update_time & 2016) >> 5;
                    d->size = finfo[i].size;
                    int q = 0;
                    for (int k = 0; k < 12 && s[k] != 0; ++k) {
                        if (s[k] != ' ') {
                            d->name[q++] = s[k];
                        }
                    }
                    d->name[q] = 0;
                    // printk("d->name = %s\n", d->name);
                    AddVal(d, result);
                }
            }
        }
    }
    return result;
}
bool Fat_RenameFile(struct vfs_t *vfs, char *filename, char *filename_of_new) {
    return rename(filename, filename_of_new, vfs);
}
bool Fat_CreateFile(struct vfs_t *vfs, char *filename) {
    return mkfile(filename, vfs);
}
void Fat_DeleteFs(struct vfs_t *vfs) {
    kfree((void *)get_dm(vfs).ADR_DISKIMG);
    kfree(get_dm(vfs).fat);
    kfree(get_dm(vfs).FatClustnoFlags);
    kfree(get_dm(vfs).root_directory);
    DeleteList(get_dm(vfs).directory_clustno_list);
    DeleteList(get_dm(vfs).directory_list);
}
bool Fat_Check(uint8_t disk_number) {
    uint8_t *boot_sec = kmalloc(512);
    Disk_Read(0, 1, boot_sec, disk_number);
 //   logk("disk number = %02x\n", disk_number);
 //for(int i = 0;i<0x200;i++) printf("%02x ",boot_sec[i]);
    if (memcmp(boot_sec + BS_FileSysType, "FAT12   ", 8) == 0 ||
        memcmp(boot_sec + BS_FileSysType, "FAT16   ", 8) == 0 ||
        memcmp(boot_sec + BS_FileSysType + BPB_Fat32ExtByts, "FAT32   ", 8) ==
        0) {
        kfree((boot_sec));
        return true;
    }
    kfree((boot_sec));
    return false;
}
bool Fat_DelFile(struct vfs_t *vfs, char *path) { return del(path, vfs); }
bool Fat_DelDict(struct vfs_t *vfs, char *path) { return deldir(path, vfs); }
int Fat_FileSize(struct vfs_t *vfs, char *filename) {
    if (Get_File_Address(filename, vfs) == NULL) {
        return -1;
    }
    return Get_File_Address(filename, vfs)->size;
}
bool Fat_Format(uint8_t disk_number) { return format(disk_number); }
bool Fat_CreateDict(struct vfs_t *vfs, char *filename) {
    struct FAT_FILEINFO *finfo = Get_dictaddr(filename, vfs);
    int last_clustno = finfo[0].clustno_low;
    if (finfo == get_dm(vfs).root_directory) {
        last_clustno = 0;
    }

    return mkdir(filename, last_clustno, vfs);
}
bool Fat_Attrib(struct vfs_t *vfs, char *filename, ftype type) {
    return attrib(filename, type, vfs);
}
vfs_file *Fat_FileInfo(struct vfs_t *vfs, char *filename) {
    struct FAT_FILEINFO *finfo = Get_File_Address(filename, vfs);
    if (finfo == NULL) {
        return NULL;
    }
    vfs_file *result = (vfs_file *)kmalloc(sizeof(vfs_file));
    char s[30];
    for (int i = 0; i != 30; i++) {
        s[i] = 0;
    }
    for (int i = 0; i < 8; i++) {
        s[i] = finfo->name[i];
    }
    s[8] = '.';
    if (finfo->ext[0] == ' ') {
        s[8] = 0;
    } else {
        s[9] = finfo->ext[0];
        s[10] = finfo->ext[1];
        s[11] = finfo->ext[2];
    }
    int i = 0;
    for (int j = 0; i < 12 && s[i] != 0; i++) {
        if (s[i] != ' ') {
            result->name[j++] = s[i];
        }
    }
    s[i] = '\0';
    if (finfo->type == 0x10) {
        result->type = DIR;
    } else if (finfo->type == 0x20) {
        result->type = FLE;
    } else if (finfo->type == 0x01) {
        result->type = RDO;
    } else if (finfo->type == 0x02) {
        result->type = HID;
    } else if (finfo->type == 0x04) {
        result->type = SYS;
    }
    result->year = (finfo->update_date & 65024) >> 9;
    result->year += 1980;
    result->month = (finfo->update_date & 480) >> 5;
    result->day = finfo->update_date & 31;
    result->hour = (finfo->update_time & 63488) >> 11;
    result->minute = (finfo->update_time & 2016) >> 5;
    result->size = finfo->size;
    return result;
}
void Register_fat_fileSys() {
    vfs_t fs;
    fs.flag = 1;
    fs.cache = NULL;
    strcpy(fs.FSName, "FAT");
    fs.CopyCache = Fat_CopyCache;
    fs.Format = Fat_Format;
    fs.CreateFile = Fat_CreateFile;
    fs.CreateDict = Fat_CreateDict;
    fs.DelDict = Fat_DelDict;
    fs.DelFile = Fat_DelFile;
    fs.ReadFile = Fat_ReadFile;
    fs.WriteFile = Fat_WriteFile;
    fs.DeleteFs = Fat_DeleteFs;
    fs.cd = Fat_cd;
    fs.FileSize = Fat_FileSize;
    fs.Check = Fat_Check;
    fs.ListFile = Fat_ListFile;
    fs.InitFs = fat_InitFS;
    fs.RenameFile = Fat_RenameFile;
    fs.Attrib = Fat_Attrib;
    fs.FileInfo = Fat_FileInfo;
    vfs_register_fs(fs);
}