Linux kernel FAT32文件系统实现
1. FAT表操作FAT文件系统中，使用FAT表标记哪个cluster被占用，哪个没被占用。在Linux内核代码中，与FAT表操作对应的是fat_entry，fatent_ops结构和fat_cache_id缓存等。1.1 fat_entryfat中的fat entry用于描述fat文件系统的FAT分配表。struct fat_entry { int e...
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
版权声明：本文为博主原创文章，转载请附上博文链接！
更多推荐
1
0- 0
已为社区贡献2条内容
所有评论(0)