Linux kernel FAT32文件系统实现

1.     FAT表操作

FAT文件系统中，使用FAT表标记哪个cluster被占用，哪个没被占用。在Linux内核代码中，与FAT表操作对应的是fat_entry，fatent_ops结构和fat_cache_id缓存等。

1.1 fat_entry

fat中的fat entry用于描述fat文件系统的FAT分配表。

struct fat_entry {

         int entry;                            // 代表当前的簇索引

         union {                                // 簇索引表

                   u8 *ent12_p[2];

                   __le16 *ent16_p;

                   __le32 *ent32_p;

         } u;

         int nr_bhs;                         // buffer_head数目，可能是1也可能是2，FAT32是1

         struct buffer_head *bhs[2];         // FAT表的扇区的buffer_head

         struct inode *fat_inode;                // 超级块的inode

};

FAT文件系统中对FAT12/16/32，分别实现了一个fatent_operations。fatent_operations的初始化在fat_ent_access_init函数，大意是根据超级块里的fat_bits判断当前FAT类型，然后将对应的fatent_operations赋值到超级块的fatent_ops中。

对于FAT32，超级块的fatent_ops会指向fat32_ops；fatent_shift为2，代表一个簇的编号占用4个字节：

static struct fatent_operations fat32_ops = {

         .ent_blocknr  = fat_ent_blocknr,

         .ent_set_ptr  = fat32_ent_set_ptr,

         .ent_bread     = fat_ent_bread,

         .ent_get = fat32_ent_get,

         .ent_put = fat32_ent_put,

         .ent_next        = fat32_ent_next,

};

fat_ent_blocknr

根据entry编号，得到block号和在block里的索引。entry为簇的索引，比如entry 5，对于FAT32它在FAT表的位置为5*4 + <FAT start>。

static void fat_ent_blocknr(struct super_block *sb, int entry, int *offset, sector_t *blocknr)

         int bytes = (entry << sbi->fatent_shift);    // FAT32中sbi->fatent_shift为2

         *offset = bytes & (sb->s_blocksize - 1);

         *blocknr = sbi->fat_start + (bytes >> sb->s_blocksize_bits);

ent_set_ptr

设置fat_entry的u.ent32_p值。

static void fat32_ent_set_ptr(struct fat_entry *fatent, int offset)

         fatent->u.ent32_p = (__le32 *)(fatent->bhs[0]->b_data + offset);

ent_bread

读FAT分配表，读到后保存到fat_entry的bhs，并将其offset开始放到u.ent32_p。

static int fat_ent_bread(struct super_block *sb, struct fat_entry *fatent, int offset, sector_t blocknr)

         struct fatent_operations *ops = MSDOS_SB(sb)->fatent_ops;

         fatent->fat_inode = MSDOS_SB(sb)->fat_inode;

         fatent->bhs[0] = sb_bread(sb, blocknr);   // 注意这里bhs是个数组，FAT32只用里面第一个，所以下面的nr_bhs为1。

         fatent->nr_bhs = 1;

         ops->ent_set_ptr(fatent, offset);

ent_get

得到当前簇号

static int fat32_ent_get(struct fat_entry *fatent)

         int next = le32_to_cpu(*fatent->u.ent32_p) & 0x0fffffff;

         if (next >= BAD_FAT32)

                   next = FAT_ENT_EOF;

         return next;

ent_put

将FAT表中某个簇的位置写成new代表的值，即更新簇链，一般在释放簇的时候会用到。

static void fat32_ent_put(struct fat_entry *fatent, int new)

         if (new == FAT_ENT_EOF)

                   new = EOF_FAT32;

         new |= le32_to_cpu(*fatent->u.ent32_p) & ~0x0fffffff;

         *fatent->u.ent32_p = cpu_to_le32(new);

         mark_buffer_dirty_inode(fatent->bhs[0], fatent->fat_inode);

ent_next

得到下一个簇，注意这里是整个FAT表的下一个簇，不是某一个文件的下一个簇。此函数在分配空闲簇、统计空闲簇是用于遍历整个FAT表。

static int fat32_ent_next(struct fat_entry *fatent)

         const struct buffer_head *bh = fatent->bhs[0];

         fatent->entry++;

         if (fatent->u.ent32_p < (__le32 *)(bh->b_data + (bh->b_size - 4))) {

                   fatent->u.ent32_p++;

                   return 1;

         }

         fatent->u.ent32_p = NULL;

1.2  fat_entry的对外接口

fat_get_cluster

fat_get_cluster根据cluster值得到该cluster在文件中以及硬盘中的簇号。这里的参数cluster是在文件中的簇号，fclus是返回的在文件中的簇号，dclus是在磁盘中的簇号。

int fat_get_cluster(struct inode *inode, int cluster, int *fclus, int *dclus)

         struct super_block *sb = inode->i_sb;

         const int limit = sb->s_maxbytes >> MSDOS_SB(sb)->cluster_bits;

         struct fat_entry fatent;

         struct fat_cache_id cid;

         *fclus = 0;

         *dclus = MSDOS_I(inode)->i_start;

         // 在cache中查找与cluster最近的fclus和dclus

         fat_cache_lookup(inode, cluster, &cid, fclus, dclus);

         。。。。。。

         fatent_init(&fatent);    // 初始化一个fat_entry

         while (*fclus < cluster) {

                   nr = fat_ent_read(inode, &fatent, *dclus);

                   。。。。。。

                   if (nr == FAT_ENT_EOF) {

                            fat_cache_add(inode, &cid);

                            goto out;

                   }

                   (*fclus)++;

                   *dclus = nr;

                   if (!cache_contiguous(&cid, *dclus))

                            cache_init(&cid, *fclus, *dclus);

         }

         // 加入缓存

         fat_cache_add(inode, &cid);

上面函数中，提到了fat_entry的缓存，其实现代码在fs/fat/chche.c，作用为根据文件中的簇号找到磁盘中的簇号。

另外，上文中调用了fat_ent_read函数，此函数执行一系列fatent_operations中的操作，例如读fat表中某一个block，查找该block中的cluster表索引，从而得到文件簇对应的磁盘簇。注意这里的读block并不一定是真正去磁盘上读，大多数情况下该block的内容会在block层的disk cache中得到。

fat_count_free_clusters

fat_count_free_clusters的作用是得到当前空闲的簇的总和，即磁盘上有多少剩余空间。此函数实现很简单，就是扫描FAT表，统计哪些簇是空闲的。扫描后的结果会保存在超级块的free_clusters中。

fat_alloc_clusters

为某个文件（inode）分配新簇，这些新簇会链接到当前文件簇链的末尾。

fat_ent_write

更新FAT表，这里的更新包括两部分，一部分为主FAT，另一部分为mirror FAT。

fat_free_clusters

释放FAT表某个簇标记，更新包括两部分，一部分为主FAT，另一部分为mirror FAT。

2.     file_operations

FAT文件系统使用的file_operations结构为fat_file_operations。

const struct file_operations fat_file_operations = {

         .llseek               = generic_file_llseek,

         .read                 = do_sync_read,   // 通用读函数，通过generic_file_aio_read实现

         .write                = do_sync_write,  // 通用写函数，通过generic_file_aio_write实现

         .aio_read         = generic_file_aio_read,      // 通用实现，通过aops实现

         .aio_write       = generic_file_aio_write, // 通用实现，通过aops实现

         .mmap              = generic_file_mmap,

         .release  = fat_file_release,

         .unlocked_ioctl      = fat_generic_ioctl,

         .fsync                = fat_file_fsync,

         .splice_read   = generic_file_splice_read,

};

先看一下FAT的读写函数的实现。

读操作

do_sync_read是kernel提供的通用同步读函数，最终会调用到file_operations的异步读写函数实现。

ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)

         。。。。。。

         filp->f_op->aio_read(&kiocb, &iov, 1, kiocb.ki_pos);

         wait_on_retry_sync_kiocb(&kiocb);

这里aio_read为generic_file_aio_read。

 

ssize_t generic_file_aio_read(struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t pos)

         if (filp->f_flags & O_DIRECT)

                   filemap_write_and_wait_range

                   mapping->a_ops->direct_IO

         。。。。。。

         do_generic_file_read

         。。。。。。

do_generic_file_read中，会先在disk cache中查找有没有对应的disk cache，如果找到则直接返回，否则调用aops->read_page调用真正的读操作，这里aops会指向fat_aops。

 

写操作

写操作与读操作类似：同步调用函数由异步调用函数实现，异步调用函数最终又是调用到aops-> write_begin和write_end。

 seek

seek函数的实现使用的是generic_file_llseek，此函数中设置了file->f_pos。

mmap

mmap的实现使用的是generic_file_mmap

int generic_file_mmap(struct file * file, struct vm_area_struct * vma)

         struct address_space *mapping = file->f_mapping;

         if (!mapping->a_ops->readpage)

                   return -ENOEXEC;

         file_accessed(file);

         vma->vm_ops = &generic_file_vm_ops;

         vma->vm_flags |= VM_CAN_NONLINEAR;

         return 0;

const struct vm_operations_struct generic_file_vm_ops = {

         .fault                 = filemap_fault,

};

generic_file_vm_ops中实现了fault函数，fault会在处理缺页异常时被调用。

int filemap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)

         // 查找对应页是否在cache中

         page = find_get_page(mapping, offset);

         if (likely(page))

                   do_async_mmap_readahead(vma, ra, file, page, offset);

         else

                   do_sync_mmap_readahead(vma, ra, file, offset);

                   page = find_lock_page(mapping, offset);

         vmf->page = page;        // 返回此page

3.     address_space_operations

file_operations结构中提到了aops结构，此结构在FAT文件系统中为fat_aops。

static const struct address_space_operations fat_aops = {
         .readpage       = fat_readpage,
         .readpages     = fat_readpages,
         .writepage      = fat_writepage,
         .writepages    = fat_writepages,
         .sync_page     = block_sync_page,
         .write_begin  = fat_write_begin,
         .write_end     = fat_write_end,
         .direct_IO        = fat_direct_IO,
         .bmap               = _fat_bmap
};

readpage

static int fat_readpage(struct file *file, struct page *page)

         return mpage_readpage(page, fat_get_block);

 

int mpage_readpage(struct page *page, get_block_t get_block)

         struct bio *bio = NULL;

         sector_t last_block_in_bio = 0;

         struct buffer_head map_bh;

         unsigned long first_logical_block = 0;

         map_bh.b_state = 0;

         map_bh.b_size = 0;

         bio = do_mpage_readpage(bio, page, 1, &last_block_in_bio,

                            &map_bh, &first_logical_block, get_block);

         if (bio)

                   mpage_bio_submit(READ, bio);

 
--------------------- 
作者：walkingman321 
来源：CSDN 
原文：https://blog.csdn.net/walkingman321/article/details/7998780 
版权声明：本文为博主原创文章，转载请附上博文链接！