fat.h

来自「AMLOGIC DPF source code」· C头文件 代码 · 共 671 行 · 第 1/2 页

{
    unsigned32     blk_num;
    avfs_boolean  modified;
    unsigned8      state;
#if 1
//by rain for alignment
    unsigned8 reserved1;
    unsigned8 reserved2;	
#endif    
    bdbuf_buffer   *buf;
} fat_cache_t;
    
/*  
 * This structure identifies the instance of the filesystem on the FAT 
 * ("fat-file") level.
 */
typedef struct fat_fs_info_s
{
    fat_vol_t      vol;           /* volume descriptor */
    Chain_Control *vhash;         /* "vhash" of fat-file descriptors */
    Chain_Control *rhash;         /* "rhash" of fat-file descriptors */
    char          *uino;          /* array of unique ino numbers */
    unsigned32     index;
    unsigned32     uino_pool_size; /* size */
    unsigned32     uino_base;
    fat_cache_t    c;             /* cache */
    unsigned8     *sec_buf; /* just placeholder for anything */
#ifdef FAT_PROTECT_SUPPORT
    char fats_sec_per_unit_log2;
    char fats_sec_per_unit;
    unsigned32* fats_modified_map;
    char* fat_buf;
#endif
} fat_fs_info_t;

/* 
 * if the name we looking for is file we store not only first data cluster
 * number, but and cluster number and offset for directory entry for this 
 * name
 */
typedef struct fat_auxiliary_s
{
    unsigned32 cln;
    unsigned32 ofs;
} fat_auxiliary_t;

#define FAT_FAT_OFFSET(fat_type, cln)                  \
    ((fat_type) & FAT_FAT12 ? ((cln) + ((cln) >> 1)) : \
     (fat_type) & FAT_FAT16 ? ((cln) << 1)           : \
     ((cln) << 2))

#define FAT_CLUSTER_IS_ODD(n)  ((n) & 0x0001)

#define FAT12_SHIFT      0x4    /* half of a byte */

/* initial size of array of unique ino */
#define FAT_UINO_POOL_INIT_SIZE  0x100

/* cache support */
#define FAT_CACHE_EMPTY   0x0
#define FAT_CACHE_ACTUAL  0x1

#define FAT_OP_TYPE_READ  0x1
#define FAT_OP_TYPE_GET   0x2

void bdbuf_mark_modified_map(fat_fs_info_t *fs_info, bdbuf_buffer  *block , unsigned32 blk, unsigned32 bytes);

void dump_vol_info(avfs_filesystem_mount_table_entry_t *mt_entry);

static inline unsigned32
fat_cluster_num_to_sector_num(
    avfs_filesystem_mount_table_entry_t *mt_entry,
    unsigned32                            cln
    )
{
    register fat_fs_info_t *fs_info = mt_entry->fs_info;
  
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
        return fs_info->vol.rdir_loc;  

    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) + 
            fs_info->vol.data_fsec);
} 

static inline unsigned32
fat_cluster_num_to_sector512_num(
    avfs_filesystem_mount_table_entry_t *mt_entry,
    unsigned32                            cln
    )
{
    fat_fs_info_t *fs_info = mt_entry->fs_info;

    if (cln == 1)
        return 1;

    return (fat_cluster_num_to_sector_num(mt_entry, cln) <<
            fs_info->vol.sec_mul);
} 

static inline int
fat_buf_access(avfs_filesystem_mount_table_entry_t *mt_entry, fat_fs_info_t *fs_info, unsigned32 blk, int op_type, 
               bdbuf_buffer **buf)
{
    avfs_status_code sc = AVFS_SUCCESSFUL;
    unsigned8         i;
    avfs_boolean     sec_of_fat;
    

    if (fs_info->c.state == FAT_CACHE_EMPTY)
    {
        if (op_type == FAT_OP_TYPE_READ)
            sc = avfs_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
        else
            sc = avfs_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);    
        if (sc != AVFS_SUCCESSFUL)
            set_errno_and_return_minus_one(EIO);
        fs_info->c.blk_num = blk;    
	fs_info->c.modified = 0;    
        fs_info->c.state = FAT_CACHE_ACTUAL;    
    }
    
#if 1 //def FAT_PROTECT_SUPPORT
    sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) && 
                  (fs_info->c.blk_num < (fs_info->vol.fat_loc+fs_info->vol.fat_length)));
#else
    sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) && 
                  (fs_info->c.blk_num < fs_info->vol.rdir_loc));
#endif
    if (fs_info->c.blk_num != blk)
    {
        if ((fs_info->c.modified)&&(mt_entry->options==AVFS_FILESYSTEM_READ_WRITE))
        {
#ifdef FAT_PROTECT_SUPPORT
            if (sec_of_fat && !fs_info->vol.mirror){
                int bit_idx;
                bit_idx=(fs_info->c.blk_num-fs_info->vol.fat_loc)>>fs_info->fats_sec_per_unit_log2;
                fs_info->fats_modified_map[bit_idx>>5] |= (1<<(bit_idx&0x1f)) ;
            }    
#else
            if (sec_of_fat && !fs_info->vol.mirror)
                memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, 
                       fs_info->vol.bps);
#endif            
            sc = avfs_bdbuf_release_modified(fs_info->c.buf);
	    fs_info->c.state = FAT_CACHE_EMPTY;
            fs_info->c.modified = 0;    
            if (sc != AVFS_SUCCESSFUL)
                set_errno_and_return_minus_one(EIO);
#ifndef FAT_PROTECT_SUPPORT
            if (sec_of_fat && !fs_info->vol.mirror)
            {
                bdbuf_buffer *b;
            
                for (i = 1; i < fs_info->vol.fats; i++)
                {
                    sc = avfs_bdbuf_read(fs_info->vol.dev,
                                         fs_info->c.blk_num + 
                                         fs_info->vol.fat_length * i, 
                                         &b);
                    if ( sc != AVFS_SUCCESSFUL)
                        set_errno_and_return_minus_one(ENOMEM);
                    memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);

                    bdbuf_mark_modified_map(fs_info, b ,fs_info->c.blk_num + fs_info->vol.fat_length * i,fs_info->vol.bps);

                    sc = avfs_bdbuf_release_modified(b);
                    if ( sc != AVFS_SUCCESSFUL)
                        set_errno_and_return_minus_one(ENOMEM);
                }
            }    
#endif            
        }
        else
        {
            fs_info->c.modified = 0;    
            sc = avfs_bdbuf_release(fs_info->c.buf);
	    fs_info->c.state = FAT_CACHE_EMPTY;
            if (sc != AVFS_SUCCESSFUL)
                set_errno_and_return_minus_one(EIO);
        
        }         
        if (op_type == FAT_OP_TYPE_READ)
            sc = avfs_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
        else
            sc = avfs_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);    
        if (sc != AVFS_SUCCESSFUL)
            set_errno_and_return_minus_one(EIO);
        fs_info->c.blk_num = blk;
	fs_info->c.state = FAT_CACHE_ACTUAL;
    }
    *buf = fs_info->c.buf;
    return RC_OK;
}


static inline int 
fat_buf_release(avfs_filesystem_mount_table_entry_t *mt_entry, fat_fs_info_t *fs_info)
{
    avfs_status_code sc = AVFS_SUCCESSFUL;
    unsigned8         i;
    avfs_boolean     sec_of_fat;
        
    if (fs_info->c.state == FAT_CACHE_EMPTY)
        return RC_OK;
            
#if 1 //def FAT_PROTECT_SUPPORT
    sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) && 
                  (fs_info->c.blk_num < (fs_info->vol.fat_loc+fs_info->vol.fat_length)));
#else
    sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) && 
                  (fs_info->c.blk_num < fs_info->vol.rdir_loc));
#endif                  
    if ((fs_info->c.modified)&&(mt_entry->options==AVFS_FILESYSTEM_READ_WRITE))
    {
#ifdef FAT_PROTECT_SUPPORT
        if (sec_of_fat && !fs_info->vol.mirror){
            int bit_idx;
            bit_idx=(fs_info->c.blk_num-fs_info->vol.fat_loc)>>fs_info->fats_sec_per_unit_log2;
            fs_info->fats_modified_map[bit_idx>>5] |= (1<<(bit_idx&0x1f)) ;
        }    
#else

        if (sec_of_fat && !fs_info->vol.mirror)
            memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
#endif            
        sc = avfs_bdbuf_release_modified(fs_info->c.buf);
        fs_info->c.state = FAT_CACHE_EMPTY;
        fs_info->c.modified = 0;    
        if (sc != AVFS_SUCCESSFUL)
            set_errno_and_return_minus_one(EIO);
          
#ifndef FAT_PROTECT_SUPPORT
        if (sec_of_fat && !fs_info->vol.mirror)
        {
            bdbuf_buffer *b;
            
            for (i = 1; i < fs_info->vol.fats; i++)
            {
                sc = avfs_bdbuf_read(fs_info->vol.dev,
                                     fs_info->c.blk_num + 
                                     fs_info->vol.fat_length * i, 
                                     &b);
                if ( sc != AVFS_SUCCESSFUL)
                    set_errno_and_return_minus_one(ENOMEM);
                memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
                
                bdbuf_mark_modified_map(fs_info, b ,fs_info->c.blk_num + fs_info->vol.fat_length * i,fs_info->vol.bps);

                sc = avfs_bdbuf_release_modified(b);

                if ( sc != AVFS_SUCCESSFUL)
                    set_errno_and_return_minus_one(ENOMEM);
            }
        }    
#endif        
    }
    else
    {
        fs_info->c.modified = 0;    
        sc = avfs_bdbuf_release(fs_info->c.buf);
        if (sc != AVFS_SUCCESSFUL)
            set_errno_and_return_minus_one(EIO);
    }         
    fs_info->c.state = FAT_CACHE_EMPTY;
    return RC_OK;
}

static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
    fs_info->c.modified = TRUE;
}



ssize_t
_fat_block_read(avfs_filesystem_mount_table_entry_t *mt_entry,
                unsigned32                            start,
                unsigned32                            offset,
                unsigned32                            count,
                void                                 *buff);

ssize_t
_fat_block_write(avfs_filesystem_mount_table_entry_t *mt_entry,
                 unsigned32                            start,
                 unsigned32                            offset,
                 unsigned32                            count,
                 const void                           *buff);

ssize_t
fat_cluster_read(avfs_filesystem_mount_table_entry_t *mt_entry,
                  unsigned32                           cln,
                  void                                *buff);

ssize_t
fat_cluster_write(avfs_filesystem_mount_table_entry_t *mt_entry,
                   unsigned32                           cln,
                   const void                          *buff);

int
fat_init_volume_info(avfs_filesystem_mount_table_entry_t *mt_entry);

int
fat_init_clusters_chain(avfs_filesystem_mount_table_entry_t *mt_entry,
                        unsigned32                            start_cln);

unsigned32
fat_cluster_num_to_sector_num(avfs_filesystem_mount_table_entry_t *mt_entry,
                              unsigned32                            cln);

int
fat_shutdown_drive(avfs_filesystem_mount_table_entry_t *mt_entry);


unsigned32
fat_get_unique_ino(avfs_filesystem_mount_table_entry_t *mt_entry);
                                                           

void
fat_free_unique_ino(avfs_filesystem_mount_table_entry_t *mt_entry,
                    unsigned32                            ino);

int
fat_fat32_update_fsinfo_sector(
  avfs_filesystem_mount_table_entry_t *mt_entry,
  unsigned32                            free_count,
  unsigned32                            next_free
  );
                       
#ifdef __cplusplus
}
#endif
                                            
#endif /* __DOSFS_FAT_H__ */