src/fat.hpp

Idź do dokumentacji tego pliku.

/* header file for src/fat.cpp */
void sub2();
#ifndef _CORE_SRC_FAT_HPP
#define _CORE_SRC_FAT_HPP
const uint32 NAME_MAX = 0x100;  /*max file name*/
/*consts for fat_type*/
const uint32 FAT_FAT12  = 12;
const uint32 FAT_FAT16  = 16;
const uint32 FAT_FAT32  = 32;
/*consts for fat_rawrw*/
const uint32 FAT_READ   = 0x0;
const uint32 FAT_WRITE  = 0x1;
/*consts for first character of the file name*/
const uint8 FAT_DIRENT_FREE             = 0xE5; /*this entry is free*/
const uint8 FAT_DIRENT_FREE2    = 0x05; /*same as above, made for compatibility with japanese charset*/
const uint8 FAT_DIRENT_ALL_FREE = 0x00; /*this and all further entries are free*/
const uint8 FAT_DIRENT_PAD              = 0x20; /*the padding for free spaces*/
extern uint8 FAT_DIRENT_ILLEGAL[];      /*all illegal characters which may not be in a direntry's name*/
 /*dirent attributes*/
const uint8 FAT_ATTR_RO         = 0x01;
const uint8 FAT_ATTR_HIDDEN     = 0x02;
const uint8 FAT_ATTR_SYSTEM     = 0x04;
const uint8 FAT_ATTR_VOLUME     = 0x08;
const uint8 FAT_ATTR_DIR        = 0x10;
const uint8 FAT_ATTR_ARCH       = 0x20;
const uint8 FAT_ATTR_LFN        = 0x0F;         /*the attr of an lfn entry*/
/*lfn*/
const uint8 LFN_SIG_MASK        = 0x1f;         /*the first 5 bits hold the sequence no*/
const uint8 LFN_SIG_LAST        = 0x40;         /*this is the last lfn entry*/
/*bad cluster marks*/
const uint32 FAT32_BAD  = 0x0FFFFFF7;
const uint32 FAT16_BAD  = 0xFFF7;
const uint32 FAT12_BAD  = 0x0FF7;
/*bootsector data*/
struct bootsect_t
 {
        char BS_jmpBoot[3];
        char BS_OEMName[8];
        uint16 BPB_BytsPerSec;
        uint8 BPB_SecPerClus;
        uint16 BPB_ResvdSecCnt;
        uint8 BPB_NumFATs;
        uint16 BPB_RootEntCnt;
        uint16 BPB_TotSec16;
        uint8 BPB_Media;
        uint16 BPB_FATSz16;
        uint16 BPB_SecPerTrk;
        uint16 BPB_NumHeads;
        uint32 BPB_HiddSec;
        uint32 BPB_TotSec32;
        union extbpb_t
         {
                struct bpb16_t
                 {
                        uint8 BS_DrvNum;
                        uint8 BS_Reserved1;
                        uint8 BS_BootSig;
                        char BS_VolID[4];
                        char BS_VolLab[11];
                        char BS_FilSysType[8];
                 } __attribute__ ((packed)) bpb16;
                struct bpb32_t
                 {
                        uint32 BPB_FATSz32;
                        uint16 BPB_ExtFlags;
                        uint16 BPB_FSVer;
                        uint32 BPB_RootClus;
                        uint16 BPB_FSInfo;
                        uint16 BPB_BkBootSec;
                        char BPB_Reserved[12];
                        uint8 BS_DrvNum;
                        uint8 BS_Reserved1;
                        uint8 BS_BootSig;
                        char BS_VolID[4];
                        char BS_VolLab[11];
                        char BS_FilSysType[8];
                 } bpb32 __attribute__ ((packed));
         } ext;
 } __attribute__ ((packed)) ;

/*a fat directory entry*/
union fatdirent_t
 {
        /*short file name entry*/
        struct sfndirent_t
        {
                char DIR_Name[11];
                uint8 DIR_Attr;
                uint8 DIR_NTRes;
                uint8 DIR_CrtTimeTenth;
                uint16 DIR_CrtTime;
                uint16 DIR_CrtDate;
                uint16 DIR_LstAccDate;
                uint16 DIR_FstClusHI;
                uint16 DIR_WrtTime;
                uint16 DIR_WrtDate;
                uint16 DIR_FstClusLO;
                uint32 DIR_FileSize;
        } sfn __attribute__ ((packed)) ;
        /*long file name entry*/
        struct lfndirent_t
        {
                uint8 DIR_Sig;
                char DIR_LName1[10];
                uint8 DIR_Attr;
                uint8 DIR_Flags;
                uint8 DIR_ChkSum;
                char DIR_LName2[12];
                uint16 DIR_First;
                uint8 DIR_LName3[4];
        } lfn __attribute__ ((packed)) ;
 };
/*struct for directory entry*/
struct dirent
 {
        char name[NAME_MAX + 1];
        uint64 size;    /*large file support*/
        uint32 parent;  /*the parent's ID*/
        uint32 block;   /*own ID*/
        uint32 flags;   /*file flags, like ro, dir etc*/
        void *resvd;
        uint32 entry_in_dir;    /*the # in the directory*/
 };

/*fat inode*/
struct fatinode_t
 {
        uint32 parent;  /*the cluster, where the parent directory starts*/
        uint32 start;   /*the first cluster of the file*/
 };

/*panaLiX devdrv and module interface*/
uint32 fat_probe(uint32 arg) asm ("__fat_probe");       /*init fat-fs module*/
// extern file_operations fat_procs;            /*file operations for this fs-mod*/

/*fat class*/
class fat_t
 {
public:
        char *path;             /*the path of the device we're reading from, relative to fs_open() etc. functions*/
//      file_handle_t *source;
        uint32 source;
        int valid;              /*whether it's valid?*/
        uint32 sector_size, cluster_size;       /*object sizes*/
        uint32 FirstDataSector;         /*the first sector of the second cluster*/
        uint32 RootDirSectors;          /*number sectors occupying the root directory*/
        uint32 FATSz;           /*single fat size*/
        uint32 TotSec, DataSec; /*total sector count and data sector count*/
        uint32 CountofClusters; /*cluster count*/
        uint32 SecPerClus;      /*sectors per cluster*/
        uint32 FirstRootDirSecNum;      /*first sector of the root directory*/
        uint32 ResvdSecCnt;             /*reserved sector count*/
        uint32 active_fat;              /*the active fat table*/

        uint32 fat_type;

        fat_t();                /*init*/
        void init();            /*init*/
        fat_t(char *ph);        /*init*/
        void init(char *ph);    /*init*/
        ~fat_t();               /*done*/
        void done();            /*done*/
        void inval();           /*discard memory*/

/*fatfs operations*/
        int verify();           /*verifies it is a fat volume*/
        int fat_rawrw(uint32 sector, char *ch, uint32 count, uint32 read_write);        /*rw access*/
        int cluster_rw(uint32 block, char *ch, uint32 count, uint32 read_write);        /*rw cluster*/
        int rootdir_rw(char *ch, uint32 read_write);    /*rw rootdir*/
        uint32 clus2sect(uint32 cluster);       /*returns first sector of cluster*/
/*FIXME*/uint32 free_clusters();                /*checks the FSI_Free_Count on the FSI sector*/
/*FIXME*/uint32 next_free();                    /*checks FSI_Nxt_Free*/
/*FIXME*/uint32 verify_boot_sector(uint32 block);       /*checks if the sector is a valid bootsector*/
/*FIXME*/uint32 get_active_table();             /*read which fat table is active*/
/*fat operations*/
        uint32 read_next_clust(uint32 table, uint32 cluster);   /*check in the fat, what does this cluster point at*/
        int write_next_clust(uint32 table, uint32 cluster, uint32 val); /*write to fat to make cluster hold the value _val*/
        uint32 cluster_no (uint32 table, uint32 first, uint32 n);       /*reads n-th cluster from first*/
        int isEOF(uint32 val);  /*checks if is EOF*/
        uint32 chain_length(uint32 first);      /*returns the length of the chain*/
        int read_chain(uint32 first, uint32 count, char *buff); /*reads a cluster chain*/
/*directory entry operations*/
        int lfn_parse_dir (char *cluster_buffer, uint32 clus, dirent *ent, uint32 *entry);      /*returns the first lfn/shn entry starting from entry in cluster*/
        int valid_lfn(fatdirent_t *ent);                /*check whether it is a lfn entry*/
        int valid_sfn(fatdirent_t *ent);                /*check whether it is a shn entry*/
        int sfn2name (char *raw, char *buff);   /*changes name from a raw-sfn format to a standard file name format.*/
        int lfn2name (fatdirent_t *first, uint32 count, char *buff);    /*convert an lfn into a standard file name*/
        int find_entry(char *name, struct dirent *ent); /*find the entry*/
        int get_file(char *name, char *buffer, uint32 clus, dirent *ent);       /*find a specific file in the directory*/

/*default file operations*/
//      int lseek ( struct file_handle_t *file, sint64 count, int whence );             /*seek*/
// // // // // // // // // //   int read ( struct file_handle_t *file, char *buff, int nbytes);                 /*read*/
        int write ( struct file_handle_t *file, char *buff, int nbytes);                /*write*/
        int readdir ( struct file_handle_t *file, struct dirent *entry, int count);     /*readdir*/
        int open  ( struct file_handle_t *file );                                                               /*open*/
        int close ( struct file_handle_t *file );                                                               /*close*/
 };

#endif

---