fat.c

Go to the documentation of this file.

#include <sys/types.h>
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <fcntl.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>
#include <stdarg.h>
#include <errno.h>
#include <ctype.h>
#include <assert.h>
#include <pthread.h>

#include <object.h>
#include <list.h>
#include <vfs.h>
#include <vfs0.h>
#include <fat0.h>
#include <fat.h>

#include <fat_cache.h>

#include <debug.h>

#define NEXT_CLUSTER(fat, c) \
do { \
        (c) = get_cluster_entry_value(&((fat)->bpb), (fat)->table, (c)); \
} while (0)

struct fatfs {
        char *node;
        struct bpb bpb;
        struct ninfo *root;
        int rootdir_sectors;

        struct fat_cache *cache;

        int fatsz;
        char *table;
};

struct ninfo_priv {
        struct fat_dentry dentry;
        int child_updated;
};

#define IS_DOT_DOTDOT(lfname) \
        lfname[0] == '.' && (!lfname[1] || (lfname[1] == '.' && !lfname[2]))

static struct DSKSZTOSECPERCLUS s_DskTableFAT16[] __UNUSED = {
        { 8400, 0 },
        { 32680, 2 },
        { 262144, 4 },
        { 524288, 8 },
        { 1048576, 16 },
        /* The entries after this point aren't used unless FAT16 is forced */
        { 2097152, 32 },
        { 4194304, 64 },
        { 0xFFFFFFFF, 0 },
};

/*
static struct DSKSZTOSECPERCLUS s_DskTableFAT32[] __UNUSED = {
        { 66600, 0 },
        { 532480, 1 },
        { 16777216, 8 },
        { 33554432, 16 },
        { 67108864, 32 },
        { 0xFFFFFFFF, 64 },
};
*/

static inline unsigned char checksum(unsigned char *name)
{
        short namelen;
        unsigned char sum;

        sum = 0;
        for (namelen = 11; namelen != 0; namelen--) {
                sum = ((sum & 0x01)? 0x80 : 0) + (sum >> 1);
                sum += (unsigned char)(*name++);
        }

        return sum;
}

static inline void from_fat12(unsigned char *fat, unsigned char *out)
{
        int idx;
        for (idx = 0; idx < 8 && fat[idx] != ' '; idx++, out++)
                *out = tolower(fat[idx]);
        *out++ = '.';

        idx = 8;
        while (idx < 11 && fat[idx] != ' ' && fat[idx] != '\0') {
                *out = tolower(fat[idx]);
                idx++;
                out++;
        }

        if (idx == 8) {
                out--;
        }
        *out = '\0';
}

static inline int update_unicode(char *wstr)
{
        unsigned short *wchar = (unsigned short *)wstr;

        while (*wchar) {
                *wstr = (char)*wchar;
                wchar++;
                wstr++;
        }
        *wstr = '\0';
        return 0;
}

static int fat_file_open(struct ninfo *ninfo, struct nctx *ctx)
{
        struct sinfo *si;
        struct fatfs *fat;

        si = ninfo->si;
        if (!si) {
                return -EINVAL;
        }

        fat = si->priv;
        if (!fat) {
                return -EINVAL;
        }

        ctx->offset = 0;
        ctx->priv = create_fat_cache(fat->node, BUFSIZ);
        return ctx->priv ? 0 : -EIO;
}

static int fat_file_close(struct ninfo *ninfo, struct nctx *ctx)
{
        struct sinfo *si;
        struct fatfs *fat;

        si = ninfo->si;
        if (!si) {
                return -EINVAL;
        }

        fat = si->priv;
        if (!fat) {
                return -EINVAL;
        }

        destroy_fat_cache(ctx->priv);
        ctx->priv = NULL;
        return 0;
}

static int fat_file_read(struct ninfo *ninfo,
                        struct nctx *ctx, void *buf, size_t size)
{
        struct sinfo *si;
        struct fatfs *fat;
        struct ninfo_priv *priv;
        int block;
        off_t off;
        int sector;
        int cluster;
        int rsize;
        char *ptr;
        size_t filesize;
        int ret;

        si = ninfo->si;
        if (!si) {
                return -EINVAL;
        }

        fat = si->priv;
        if (!fat) {
                return -EINVAL;
        }

        priv = ninfo->priv;
        if (!priv) {
                return -EINVAL;
        }

        filesize = ninfo->size;
        if (filesize <= ctx->offset) {
                return EOF;
        }

        block = ctx->offset / fat->bpb.sector_size;

        cluster = GET_FIRST_BLOCK(&priv->dentry);

        while (block-- > 0) {
                filesize -= fat->bpb.sector_size;

                NEXT_CLUSTER(fat, cluster);
                if (IS_EOF(&fat->bpb, cluster) || (filesize <= 0)) {
                        return EOF;
                }
        }

        ptr = buf;
        rsize = 0;
        while (filesize > 0 && size > 0 && !IS_EOF(&fat->bpb, cluster)) {
                sector = FIRST_SECTOR_OF_CLUSTER(&fat->bpb, cluster);

                block = 0;
                off = sector * fat->bpb.sector_size;
                off += (ctx->offset % fat->bpb.sector_size);
                while (block < fat->bpb.sector_per_cluster && size > 0 && filesize > 0) {
                        ret = update_fat_cache(ctx->priv, off);
                        if (ret < 0) {
                                return ret;
                        }

                        ret = off % fat_cache_size(ctx->priv);

                        rsize = fat_cache_size(ctx->priv) - ret;
                        rsize = rsize > filesize ? filesize : rsize;
                        rsize = rsize > size ? size : rsize;

                        memcpy(ptr, fat_cache(ctx->priv) + ret, rsize);
                        ctx->offset += rsize;

                        block++;
                        ptr += rsize;
                        size -= rsize;
                        filesize -= rsize;
                        off += rsize;
                }

                NEXT_CLUSTER(fat, cluster);
        }

        return (uint32_t)ptr - (uint32_t)buf;
}

static int fat_file_write(struct ninfo *_this,
                        struct nctx *ctx, const void *buf, size_t size)
{
        return -ENOSYS;
}

static off_t fat_file_lseek(struct ninfo *ninfo,
                                struct nctx *ctx, off_t off, int whence)
{
        switch (whence) {
        case SEEK_SET:
                ctx->offset = off;
                break;
        case SEEK_CUR:
                ctx->offset += off;
                break;
        case SEEK_END:
                ctx->offset = ninfo->size + off;
                break;
        default:
                return (off_t)-1;
        }

        return ctx->offset;
}

static inline int load_fat(struct fatfs *fat)
{
        int ret;
        int off;
        int rsize;
        int size;
        char *ptr;

        fat->fatsz = FAT_SIZE(&fat->bpb) * fat->bpb.sector_size;
        fat->table = malloc(fat->fatsz);
        if (!fat->table) {
                return -ENOMEM;
        }

        ptr = fat->table;
        off = THIS_FAT_OFFSET(&fat->bpb, 0);
        size = fat->fatsz;

        while (size > 0) {
                ret = update_fat_cache(fat->cache, off);
                if (ret < 0) {
                        free(fat->table);
                        return ret;
                }

                ret = off % fat_cache_size(fat->cache);
                rsize = fat_cache_size(fat->cache) - ret;
                rsize = rsize > size ? size : rsize;

                memcpy(ptr, fat_cache(fat->cache) + ret, rsize);

                ptr += rsize;
                off += rsize;
                size -= rsize;
        }

        return 0;
}

static inline void read_slots(struct ninfo *root, int sector,
                        int *cont, unsigned char *chksum, unsigned char *lfname)
{
        struct fat_dentry *dentry;
        off_t offset;
        struct fatfs *fat;
        int nr_of_slots;

        fat = root->si->priv;
        nr_of_slots = fat->bpb.sector_size / sizeof(*dentry);
        offset = sector * fat->bpb.sector_size;

        update_fat_cache(fat->cache, offset);
        offset %= fat_cache_size(fat->cache);

        dentry = (struct fat_dentry *)(fat_cache(fat->cache) + offset);
        while (nr_of_slots-- > 0) {
                if (IS_FREE_DENTRY(dentry)) {
                        if (*cont != 0) {
                                printf("Skip: cont isn't ZERO\n");
                                *cont = 0;
                        }
                        dentry++;
                        continue;
                }

                if (dentry->attr == ATTR_EXT) {
                        struct fat_long_dirent *lentry;
                        unsigned char *tmp;

                        lentry = (struct fat_long_dirent *)dentry;

                        if (!*cont) {
                                if ((lentry->ord & 0x40) != 0x40) {
                                        printf("Invalid slot\n");
                                        *chksum = 0;
                                        dentry++;
                                        continue;
                                }
                                *cont = lentry->ord & 0x0F;
                                *chksum = lentry->checksum;
                        } else {
                                if ((lentry->ord & 0x40) != 0x0) {
                                        printf("Invalid slot\n");
                                        dentry++;
                                        *chksum = 0;
                                        continue;
                                }

                                if (*cont != (lentry->ord & 0x0F)) {
                                        printf("Invalid seq\n");
                                        dentry++;
                                        *chksum = 0;
                                        continue;
                                }

                                if (*chksum != lentry->checksum) {
                                        printf("Invalid checksum\n");
                                        dentry++;
                                        *chksum = 0;
                                        continue;
                                }
                        }

                        (*cont)--;

                        tmp = lfname + (*cont * 26);
                        memcpy(tmp, lentry->name1, 10);
                        tmp += 10;
                        memcpy(tmp, lentry->name2, 12);
                        tmp += 12;
                        memcpy(tmp, lentry->name3, 4);
                        tmp += 4;
                } else {
                        struct ninfo *ninfo;

                        if (*cont != 0) {
                                printf("lfn is invalid [%d]\n", *cont);
                                dentry++;
                                *cont = 0;
                                *chksum = 0;
                                continue;
                        }

                        if (!*chksum || checksum(dentry->name) != *chksum) {
                                from_fat12(dentry->name, lfname);
                        } else {
                                update_unicode((char *)lfname);
                        }

                        if (IS_DOT_DOTDOT(lfname)) {
                                dentry++;
                                continue;
                        }

                        ninfo = vfs_new_ninfo(NULL, root, (char *)lfname, dentry);
                        if (!ninfo) {
                                printf("Create failed [%s]\n", lfname);
                                dentry++;
                                continue;
                        }
                }
                dentry++;
        }
}

static inline void load_rootdir(struct ninfo *parent)
{
        int sector;
        int nr_of_sectors;
        struct fatfs *fat;
        struct ninfo_priv *priv;
        unsigned char chksum;
        unsigned char lfname[PATH_MAX];
        int cont;

        priv = parent->priv;
        if (priv) {
                priv->child_updated = 1;
        }

        fat = parent->si->priv;
        assert(fat && "fat is not valid");

        sector = FIRST_ROOTDIR_SECTOR(&fat->bpb);
        nr_of_sectors = ROOT_DIR_SECTORS(&fat->bpb);
        cont = 0;

        while (nr_of_sectors-- > 0) {
                read_slots(parent, sector, &cont, &chksum, lfname);
                sector++;
        } /* while in parent dir sectors */
}

static struct ninfo *get_ninfo(struct sinfo *this, unsigned long id)
{
        if (id == ROOT_NINFO) {
                struct fatfs *fat;
                fat = this->priv;
                if (!fat) {
                        return NULL;
                }

                return fat->root;
        }

        return NULL;
}

static void refresh_children(struct sinfo *sinfo, struct ninfo *root)
{
        int cluster;
        int sector;
        unsigned char chksum;
        unsigned char lfname[PATH_MAX];
        struct ninfo_priv *priv;
        struct fatfs *fat;
        int cont;
        int block;

        if (root->type != NINFO_TYPE_FOLDER) {
                return;
        }

        priv = root->priv;
        if (!priv || priv->child_updated) {
                return;
        }

        priv->child_updated = 1;
        fat = root->si->priv;

        cluster = GET_FIRST_BLOCK(&priv->dentry);
        cont = 0;

        while (!IS_EOF(&(fat->bpb), cluster)) {
                sector = FIRST_SECTOR_OF_CLUSTER(&(fat->bpb), cluster);
                for (block = 0; block < fat->bpb.sector_per_cluster; block++) {
                        read_slots(root, sector, &cont, &chksum, lfname);
                        sector++;
                }

                NEXT_CLUSTER(fat, cluster);
        }
}

static int fill_ninfo(struct sinfo *this, struct ninfo *parent,
                struct ninfo *ninfo, void *info)
{
        struct ninfo_priv *priv;
        struct fat_dentry *dentry = info;
        
        if (!ninfo) {
                return -EINVAL;
        }

        if (dentry->attr & ATTR_DIR) {
                ninfo->type = NINFO_TYPE_FOLDER;
        } else {
                ninfo->type = NINFO_TYPE_FILE;
        }

        ninfo->nops.open = fat_file_open;
        ninfo->nops.read = fat_file_read;
        ninfo->nops.write = fat_file_write;
        ninfo->nops.close = fat_file_close;
        ninfo->nops.lseek = fat_file_lseek;
        ninfo->id = GET_FIRST_BLOCK(dentry);
        ninfo->size = dentry->file_size;

        priv = malloc(sizeof(*priv));
        if (!priv) {
                return -ENOMEM;
        }

        priv->child_updated = 0;
        memcpy(&priv->dentry, dentry, sizeof(*dentry));
        ninfo->priv = priv;

        return 0;
}

static int del_ninfo(struct sinfo *this, struct ninfo *node)
{
        /* TODO: Update FAT table */
        return 0;
}

inline static void dump_bpb(struct bpb *boot)
{
        printf("Jump Instruction : [0x%x 0x%x]\n", boot->jmp[0], boot->jmp[1]);
        printf("NOP Instructrion : [0x%x]\n", boot->nop);
//      printf("OEM : [%.*s]\n", sizeof(boot->oem), boot->oem);
        printf("Sector size : [%d]\n", boot->sector_size);
        printf("Sector per cluster : [%d]\n", boot->sector_per_cluster);
        printf("Reserved sector count : [%d]\n", boot->reserved_sector);
        printf("Number of FATs : [%d]\n", boot->nr_fat);

        printf("Media type : 0x%x (? F0 : Removal)\n", boot->media_type);
        printf("Size of a FAT : [%d]\n", boot->size_of_fat16);
        printf("Sectors per a track : [%d]\n", boot->sector_per_track);
        printf("Number of heads : [%d]\n", boot->nr_head);
        printf("Hidden sectors : [%d]\n", boot->hidden_sector);
        printf("Total sectors : [%d]\n", boot->total_sector16);
        printf("Boot drive : [%d]\n", boot->type.fat16.boot_drive);
        printf("Boot signature : [%x]\n", boot->type.fat16.boot_signature);
        printf("Volume ID : [%x]\n", boot->type.fat16.volume_id);
//      printf("Volume label : [%.*s]\n", sizeof(boot->type.fat16.volume_label), boot->type.fat16.volume_label);
//      printf("FS type : [%.*s]\n", sizeof(boot->type.fat16.fs_type), boot->type.fat16.fs_type);
}

struct ninfo *fat_load(struct ninfo *parent, const char *node)
{
        struct sinfo *si;
        struct fatfs *fat;
        int ret;
        struct ninfo *root;

        si = malloc(sizeof(*si));
        if (!si) {
                dbg_printf("malloc: si(%d)\n", sizeof(*si));
                return NULL;
        }

        INIT_LIST_HEAD(&si->head);
        si->refcnt = 0;

        si->get_ninfo = get_ninfo;
        si->fill_ninfo = fill_ninfo;
        si->del_ninfo = del_ninfo;
        si->refresh_children = refresh_children;

        root = vfs_new_ninfo(si, parent, "fat", NULL);
        if (!root) {
                free(si);
                dbg_printf("Failed to create a fat node\n");
                return NULL;
        }

        root->type = NINFO_TYPE_FOLDER;

        fat = malloc(sizeof(*fat));
        if (!fat) {
                free(si);
                vfs_del_ninfo(root);
                dbg_printf("malloc: fat(%d)\n", sizeof(*fat));
                return NULL;
        }

        fat->node = strdup(node);
        if (!fat->node) {
                free(fat);
                free(si);
                vfs_del_ninfo(root);
                dbg_printf("stdup: %s\n", node);
                return NULL;
        }

        fat->cache = create_fat_cache(fat->node, BUFSIZ);
        if (!fat->cache) {
                free(fat->node);
                free(fat);
                free(si);
                vfs_del_ninfo(root);
                dbg_printf("Failed to create cache\n");
                return NULL;
        }

        ret = update_fat_cache(fat->cache, 0);
        if (ret < 0) {
                destroy_fat_cache(fat->cache);
                free(fat->node);
                free(fat);
                free(si);
                vfs_del_ninfo(root);
                dbg_printf("Failed to access FDD\n");
                return NULL;
        }

        memcpy(&fat->bpb, fat_cache(fat->cache), sizeof(fat->bpb));

        dump_bpb(&fat->bpb);

        fat->root = root;
        si->priv = fat;

        ret = load_fat(fat);
        if (ret < 0) {
                destroy_fat_cache(fat->cache);
                free(fat->node);
                free(fat);
                free(si);
                vfs_del_ninfo(root);
                dbg_printf("Failed to load FAT\n");
                return NULL;
        }

        load_rootdir(fat->root);
        return root;
}

/* End of a file */