EEPW论坛

三、jffs的挂接

1、read super
当通过命令mount -t jffs /dev/mtdblock0 /mnt/flash将文件系统mount到设备上的时候，通过sys_mount系统调用进入内核，并通过具体的文件系统的read_super函数建立起vfs的各种数据结构。
/* Called by the VFS at mount time to initialize the whole file system. */
static struct super_block * jffs_read_super(struct super_block *sb, void *data, int silent)
{
kdev_t dev = sb->s_dev;
struct inode *root_inode;
struct jffs_control *c;
//jffs文件系统要求mount的设备必须是mtd
if (MAJOR(dev) != MTD_BLOCK_MAJOR) {
printk(KERN_WARNING "JFFS: Trying to mount a "
"non-mtd device.\n");
return 0;
}

sb->s_blocksize = PAGE_CACHE_SIZE; //设定块的大小
sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
sb->u.generic_sbp = (void *) 0;
sb->s_maxbytes = 0xFFFFFFFF; //Maximum size of the files

//通过jffs_build_fs扫描整个flash，然后通过flash上的内容建立完整的文件树，对于jffs文件系统，所有的文件都在ram中有对应的结构，不论该文件是否打开
/* Build the file system. */
if (jffs_build_fs(sb) < 0) { //该函数下面具体分析
goto jffs_sb_err1;
}

/*
* set up enough so that we can read an inode
*/
sb->s_magic = JFFS_MAGIC_SB_BITMASK; //设置文件系统魔术
sb->s_op = &jffs_ops; //设置super block的操作方法

//jffs文件系统最小的inode number是JFFS_MIN_INO="1"，这里建立根的inode结构
//对于一个表示jffs文件的inode结构，inode->u.generic_ip是指向一个表示该文件的struct jffs_file结构。通过jffs_read_inode，可以将根的inode设置好，包括上面的inode->u.generic_ip，还有inode->i_op inode->i_fop
root_inode = iget(sb, JFFS_MIN_INO);
if (!root_inode)
goto jffs_sb_err2;

//这里建立根的dentry结构
/* Get the root directory of this file system. */
if (!(sb->s_root = d_alloc_root(root_inode))) {
goto jffs_sb_err3;
}

//获得sb中jffs_control的指针
c = (struct jffs_control *) sb->u.generic_sbp;

/* Set the Garbage Collection thresholds */
//当flash上的free size小于gc_minfree_threshold的时候，会启动垃圾回收，以便释放一些空间
/* GC if free space goes below 5% of the total size */
c->gc_minfree_threshold = c->fmc->flash_size / 20;

if (c->gc_minfree_threshold < c->fmc->sector_size)
c->gc_minfree_threshold = c->fmc->sector_size;
//当flash上的dirty size大于gc_maxdirty_threshold的时候，会启动垃圾回收，以便释放一些空间
/* GC if dirty space exceeds 33% of the total size. */
c->gc_maxdirty_threshold = c->fmc->flash_size / 3;

if (c->gc_maxdirty_threshold < c->fmc->sector_size)
c->gc_maxdirty_threshold = c->fmc->sector_size;

//启动垃圾回收的内核线程
c->thread_pid = kernel_thread (jffs_garbage_collect_thread,
(void *) c,
CLONE_FS | CLONE_FILES | CLONE_SIGHAND);

return sb;

jffs_sb_err3:
iput(root_inode);
jffs_sb_err2:
jffs_cleanup_control((struct jffs_control *)sb->u.generic_sbp);
jffs_sb_err1:
printk(KERN_WARNING "JFFS: Failed to mount device %s.\n",
kdevname(dev));
return 0;
}

2、初始化fs，建立文件树
/* This is where the file system is built and initialized. */
int jffs_build_fs(struct super_block *sb)
{
struct jffs_control *c;
int err = 0;

//创建jffs_control和jffs_fmcontrol结构，并初始化jffs_control中的哈西表，根据mount的mtd设备，初始化jffs_fmcontrol
if (!(c = jffs_create_control(sb->s_dev))) {
return -ENOMEM;
}
c->building_fs = 1; //标示目前正在building fs
c->sb = sb;

//通过jffs_scan_flash扫描整个flash，建立相关的fs的结构，下面会详细分析
if ((err = jffs_scan_flash(c)) < 0) {
if(err == -EAGAIN){
//如果发现flipping bits，则重新扫描，所谓flipping bits是由于在erase sector的时候，突然断电而造成flash上该扇区内容不确定
jffs_cleanup_control(c); //清除发现flipping bits之前创建的结构
if (!(c = jffs_create_control(sb->s_dev))) {
return -ENOMEM;
}
c->building_fs = 1;
c->sb = sb;

if ((err = jffs_scan_flash(c)) < 0) { //重新扫描
goto jffs_build_fs_fail;
}
}else{
goto jffs_build_fs_fail;
}
}

//在flash上有所有文件和目录的jffs_raw_inode结构，但是没有根文件的结点，所以我们一般要通过jffs_add_virtual_root手动创建根文件的相关结构。jffs_find_file是通过inode number在哈西表中查找该jffs_file
if (!jffs_find_file(c, JFFS_MIN_INO)) {
if ((err = jffs_add_virtual_root(c)) < 0) {
goto jffs_build_fs_fail;
}
}
//由于各种原因，扫描结束后，可能有些文件是要删除的，下面的代码执行删除任务
while (c->delete_list) {
struct jffs_file *f;
struct jffs_delete_list *delete_list_element;

if ((f = jffs_find_file(c, c->delete_list->ino))) {
f->deleted = 1;
}
delete_list_element = c->delete_list;
c->delete_list = c->delete_list->next;
kfree(delete_list_element);
}

//有些节点被标记delete，那么我们要去掉这些deleted nodes
if ((err = jffs_foreach_file(c, jffs_possibly_delete_file)) < 0) {
printk(KERN_ERR "JFFS: Failed to remove deleted nodes.\n");
goto jffs_build_fs_fail;
}
//去掉redundant nodes
jffs_foreach_file(c, jffs_remove_redundant_nodes);

//从扫描的所有的jffs_node 和 jffs_file 结构建立文件树
if ((err = jffs_foreach_file(c, jffs_insert_file_into_tree)) < 0) {
printk("JFFS: Failed to build tree.\n");
goto jffs_build_fs_fail;
}
//根据每一个文件的版本链表，建立文件的区域链表
if ((err = jffs_foreach_file(c, jffs_build_file)) < 0) {
printk("JFFS: Failed to build file system.\n");
goto jffs_build_fs_fail;
}
//建立vfs和具体文件系统的关系
sb->u.generic_sbp = (void *)c;
c->building_fs = 0; //标示building fs 结束

return 0;

jffs_build_fs_fail:
jffs_cleanup_control(c);
return err;
} /* jffs_build_fs() */


3、扫描flash

jffs_scan_flash是一个很长的函数，下面我们只是描述函数的结构
static int jffs_scan_flash(struct jffs_control *c)
{
pos = 0 //pos 表示当前flash上扫描的位置

通过check_partly_erased_sectors函数检查flipping bits

while (读到flash最后一个byte) {

//从当前位置读从一个u32
switch (flash_read_u32(fmc->mtd, pos)) {
case JFFS_EMPTY_BITMASK:
如果读到的字节是JFFS_EMPTY_BITMASK也就是0xffffffff，那么该位置上flash是free的，我们还没有使用它，接着就会用一个4k的buffer去读直到不是JFFS_EMPTY_BITMASK的位置停止。
case JFFS_DIRTY_BITMASK:
如果读到的字节是JFFS_DIRTY_BITMASK也就是0x00000000，那么读出所有的连续的0x00000000,分配一个jffs_fm结构表示该区域，但是jffs_fm->nodes为空，也就是标示该区域为dirty，并把该jffs_fm连接到jffs_fmcontrol的双向链表中。一般这种区域是由于到了flash的末尾，剩余的空间不够写一个jffs_raw_inode结构，所以全部写0

case JFFS_MAGIC_BITMASK:
找到一个真正的jffs_raw_inode结构，将该raw indoe 读出来，如果是一个bad raw inode(例如校验错误等等），那么分配一个jffs_fm结构表示该区域，但是jffs_fm->nodes为空，也就是标示该区域为dirty；如果是一个good inode，那么建立jffs_node结构和jffs_fm结构，并把该jffs_fm连接到jffs_fmcontrol的双向链表中，然后把jffs_node插入到jffs_file的version list中，表明该node的文件的jffs_file结构先通过哈西表查找，如果没有则创建，一般来说，如果这个jffs_node是扫描到的该文件的第一个节点，那么就需要创建jffs_file结构，此后就可以通过哈西表找到该jffs_file结构。

}

}
解释：
（1）通过上面的循环，可以建立所有的文件的jffs_file结构，并且version list已经建好，但是range list还没有建立，文件还不能正常读写
（2）通过上面的循环，可以建立表示flash使用情况的jffs_fmcontrol结构，并且所有的used_size都已经通过jffs_fm联接成链表。
}

四、文件打开

五、文件读写
六、垃圾回收

在Linux环境下，JFFS似乎是不错的选择。但是JFFS启动时速度很慢，YAFFS速度会快很多，内存需求也少些。
如果内存紧张而没有操作系统支持，又要求快速启动，可以试试UFFS。

有垃圾回收部分的说明吗？

ding!

不错