1. 技术文章
  2. UBIFS文件系统

UBIFS文件系统

由 冷暖自知 提交于 2019-12-19 12:54:34

引言

什么是UBIFS文件系统

UBIFS是UBI file system的简称，用于裸的flash设备，作为jffs2的后继文件系统之一。UBIFS通过UBI子系统处理与MTD设备之间动作。UBIFS文件系统更适合MLCNAND FLASH。需要注意的是UBIFS并不是为SSD，MMC，SD，Compact Flash等之类的基于flash的存储设备，其是针对于裸flash设备。

         裸flash有以下特点：

l  其包含的块被称为可擦除块，而对于SSD这类的设备，并无可擦除块的概念，取而代之的是扇区的概念。

l  包括读、写、擦除可擦除块三种操作。

l  硬件并不管理坏的可擦除块，而SSD之类的设备则具有专门的控制器处理坏块。

l  可擦除块的读写寿命从几千到几十万之间不等。

图0.1中给出的设备是MMC、SD类型的，该设备具有flash转换层的硬件控制器，该硬件控制器的损耗平衡算法属于商业秘密，华为的dorado 系列高端存储器的文档对其损耗平衡（动态和静态）原理讲解的非常透彻，感兴趣的可以自己找找。对于UBIFS使用的场景，通常只有NANDFLASH那一个模块，其和控制器的接口通常是专门的NAND flash接口。由于这类设备的速率比较慢，所以通常用在相对而言比较低端的嵌入式设备，追求加载速度快一点嵌入式设备通常会选择使用emmc存储器，其文件系统通常会选择UFS。

图0.1 具有flash转换层的设备

UBI/UBIFS 协议栈

图0.2 UBIFS实现的协议栈

MTD(Memory Technology Devices)对闪存存储器提供了一个抽象，隐藏了特定flash的独特之处，提供统一的API存取各种类型的flash。

MTD在内核层的API是struct mtd_device而用户空间的API接口是/dev/mtd0，这些接口提供了设备信息，读写可擦除块，擦除一个可擦除块，标记一个可擦除块是坏块，检查可擦除块是否是坏块。MTD的API并不隐藏坏的可擦除块也不做任何损耗平衡。

UBI（Unsorted Block Images）的内核API是include/mtd/ubi-user.h，用户空间的则是/dev/ubi0，提供损耗平衡，隐藏坏块，允许运行时容量创建、删除和修改，有点类似LVM功能。UBI线性扩展，在初始化时会读取所有的可擦除块头，所以当flash容量越大，初始化所花费的时间越多，但是就可扩展性而言比JFFS2要好很多。

LEB（logic eraseblock），PEB（physical erase block）；将LEB映射到PEB，任何一个LEB可能映射到任何一个PEB，可擦除块头存储的是映射信息以及擦除计数值。

图0.3 UBI基本思想

UBI坏的可擦除块处理：

l  为坏的可擦除块预留1%的PEB

l  如果一个PEB变成坏块，则相应的LEB会被映射到一个好的PEB中

l  I/O错处处理对上层并未隐藏。

写错误处理

假设用户写数据到LEB0可擦除块，选择一个好的PEB可擦除块（这里假设选择PEB4）来恢复数据，恢复数据实际上就是将数据拷贝到PEB4，然后重新映射LEB0到PEB4，映射完毕后将新数据再次写入PEB4，这是恢复就完成了，将回到UBI层，后台会将PEB1标记为坏块。

图0.4 写错误处理示例

原子改变LEB

这对UBIFS非常重要，假设LEB0需要被原子改变，这一过程是这样的：

         首先选择一个合适的PEB块，加入这里选择了PEB0，然后向这个块写入新数据，写入完成后需要将原始映射PEB4解映射同时将LEB0映射到PEB0，这是就完成了原子更新操作返回UBI层，但是PEB4的数据会被后台擦除。

图0.5 原子改变LEB

对UBI底层的操作有了一些了解后，可以开始UBIFS的介绍了，首先UBIFS并不关系可擦除坏块了，这一信息依赖于UBI层，损耗平衡依赖于UBI层而不是UBIFS，LEB的更改是原子性的。

         UBIFS文件索引

索引允许查找任何数据片段的物理地址。索引采用B+2的结构，图中右上半部分，只有叶子节点包含数据，数的扇出可配，缺省值是8。UBIFS的索引在flash上存储和维护。

图0.6 UBIFS索引

 

UBIFS日志

 

日志比较小，为节省功耗只扫描日志并不扫描flash所有数据，这一结果会让挂载很快完成。文件系统所有更改将被日志记录，索引信息只在内存修改，并不在flash上修改。

         主节点存在于LEB1和LEB2，这两个块存储的是一样的，用于备份恢复之用，主节点指向根索引，主分区在挂载时可以很快被找到。

 

图0.7 索引和UBIFS的关系

超级块

超级块存储在LEB0位置处，对于UBIFS文件系统只读，但是可以被用户空间工具修改，存储如索引树扇出等一些配置信息，缺省使用zlib或者LZO进行压缩，在挂载该文件系统时，UBIFS的mount方法将被调用读取该超级块。

树节点缓存（TreeNode Cache）

         为了加速文件的操作，每次更新flash上的索引树的速率较慢，所以在内存中建立树节点缓存以加快索引树查找。

垃圾回收

有一个空的LEB专门为垃圾回收保留。垃圾回收的一个例子如下：

首先选择一个脏LEB，比如LEB1被选中，然后将其有效数据拷贝的到LEB5，LEB1这时就可以被擦除了，然后再选择一个脏LEB区，如LEB6，同样将数据拷贝到LEB5，拷贝完成后LEB6上的原有数据可能被擦除掉，LEB1将未垃圾回收预留，LEB6这时处于可用状态。索引处理方法，只是将Tree Node Cache的索引节点标记为脏。这样垃圾回收完成。但是还进行一个确认操作，确认操作肯定是可以完成的，会为索引预留至少3倍的空闲空间。

图0.8 垃圾回收原理

LPT（LEB Properites Tree）

         是一个B+树，但是大小固定，比主索引树小很多，管理方法类似于主索引树。

UBIFS初始化

UBIFS的文件系统需要编译的文件如下fs/ubifs/Makefile ，最后会编译成ubifs.o这个文件，链接时会将该文件链接到镜像文件中去。

Shrinker是动态调整树大小的。Journal是UBIFS的日志功能实现的文件，file、dir、super、sb以及io是文件、目录、超级块以及io操作实现；

Tnc(tree nodecache)模块，commit是在垃圾回收确认会用到的操作。gc是垃圾回收实现源码。

 

为了知道该模块的注册过程，首先查找相关的init函数。

 

         透过上面的两个查找可以知道，UBIFS子系统在加载时会首先执行ubifs_init函数，这很late_initcall在《Linux系统启动那些事—基于Linux 3.10内核》一文提到过其调用的时机，在系统启动时会被调用。

[cpp] view plain copy

  1. Super.c  
  2.     static int __init ubifs_init(void)  
  3. {  
  4. 首先申请一个slab分配器，关于slab见《内存管理-之内核内存管理-基于linux3.10》  
  5.     ubifs_inode_slab = kmem_cache_create("ubifs_inode_slab",  
  6.                 sizeof(struct ubifs_inode), 0,  
  7.                 SLAB_MEM_SPREAD | SLAB_RECLAIM_ACCOUNT,  
  8.                 &inode_slab_ctor);  
  9. //将ubifs_shrinker（定义于shrinker.c文件）注册到VM子系统，在cache压力较大时，将会缩小TNC（tree node cache）。  
  10. register_shrinker(&ubifs_shrinker_info);  
  11. //UBIFS文件系统支持两种压缩格式lzo和zlib，该函数定义于compress.c文件，两种压缩格式在编译时根据宏选定。  
  12.     err = ubifs_compressors_init();  
  13. //注册该文件系统，这个过程见《虚拟文件系统 (VFS)-基于linux3.10》，这里比较感兴趣的是ubifs_fs_type  
  14.     err = register_filesystem(&ubifs_fs_type);  
  15. }  

mount方法才是最感兴趣的，在《虚拟文件系统 (VFS)-基于linux3.10》里提到文件系统挂载时会调用具体的文件系统的mount方法，这里就来看看它的mount方法。

[cpp] view plain copy

  1. <super.c>  
  2. static struct file_system_type ubifs_fs_type = {  
  3.     .name    = "ubifs",  
  4.     .owner   = THIS_MODULE,  
  5.     .mount   = ubifs_mount,  
  6.     .kill_sb = kill_ubifs_super,  
  7. };  

Mount的函数虽然很重要，但是并没有想象中那么复杂，逻辑结构相对比较明晰。该函数首先调用open_ubi打开一个UBI设备，之所以以只读方式打开是因为这也许是一个新的挂载点，UBI同一时刻只允许有一个读写者。alloc_ubifs_info为描述UBIFS文件系统的结构体struct ubifs_info申请内存，并且初始化自旋锁、互斥锁、链表、树节点等操作。Sget首先在该文件系统中查找超级块，如果没有找到则调用alloc_super创建一个超级块，并初始化超级块的相关成员，该函数并未定义于ubifs文件目录内。然后调用ubifs_fill_super对超级块进行填充，填充的信息源于LEB0，这涉及到UBI和MTD层。由于fill_super()函数在一次打开了UBI，所以这里调用ubi_close_volume将其关闭。最后调用dget返回目录项。

图1.1 UBIFS挂载过程

假设挂载形式如《虚拟文件系统 (VFS)-基于linux3.10》提到的，如：

[cpp] view plain copy

  1. mount   –t     ubifs               /dev/ubi4_0                         /config  

则open_ubi调用ubi_open_volume_path(“/dev/ubi4_0”,UBI_READONLY)查找UBI卷描述符。

[cpp] view plain copy

  1. struct ubi_volume_desc *ubi_open_volume_path(const char *pathname, int mode)  
  2. {  
  3. //该函数分析见《虚拟文件系统 (VFS)-基于linux3.10》  
  4.     error = kern_path(pathname, LOOKUP_FOLLOW, &path);  
  5.   
  6.     inode = path.dentry->d_inode;  
  7.     mod = inode->i_mode;  
  8. //获得主次设备号  
  9.     ubi_num = ubi_major2num(imajor(inode));  
  10.     vol_id = iminor(inode) - 1;  
  11.     path_put(&path);  
  12.   
  13. UBI卷描述符的获取  
  14.     if (vol_id >= 0 && ubi_num >= 0)  
  15.         return ubi_open_volume(ubi_num, vol_id, mode);  
  16. }  

ubi_open_volume获取UBI卷描述符，主要依赖前两个参数，第一个参数是UBI主设备号对应的数字，而第二个参数是UBI次设备号对应的数字。由主设备号索引到ubi设备，ubi_devices是一个局部全局的描述ubi设备的数组。

[cpp] view plain copy

  1. struct ubi_device *ubi;  
  2. ubi = ubi_devices[ubi_num];  

根据ubi设备信息找到UBI卷：

[cpp] view plain copy

  1. vol = ubi->volumes[vol_id];  

alloc_ubifs_info主要功能就是slab分配内存，不多解释，有兴趣见《内存管理-之内核内存管理-基于linux3.10》。

sget用于查找并创建超级块

[cpp] view plain copy

  1. struct super_block *sget(struct file_system_type *type,  
  2.             int (*test)(struct super_block *,void *),  
  3.             int (*set)(struct super_block *,void *),  
  4.             int flags,  
  5.             void *data)  
  6. {  
  7.     struct super_block *s = NULL;  
  8.     struct super_block *old;  
  9.     int err;  
  10.   
  11. retry:  
  12.     spin_lock(&sb_lock); //获得超级块锁  
  13. //这个if语句就是在现有的文件系统中查找超级块是否存在  
  14.     if (test) { //这个函数在存在，实际上就是sb_test函数。  
  15.         hlist_for_each_entry(old, &type->fs_supers, s_instances) {  
  16.             if (!test(old, data))  
  17.                 continue;  
  18.             if (!grab_super(old))  
  19.                 goto retry;  
  20.             if (s) {  
  21.                 up_write(&s->s_umount);  
  22.                 destroy_super(s);  
  23.                 s = NULL;  
  24.             }  
  25.             down_write(&old->s_umount);  
  26.             if (unlikely(!(old->s_flags & MS_BORN))) {  
  27.                 deactivate_locked_super(old);  
  28.                 goto retry;  
  29.             }  
  30.             return old;  
  31.         }  
  32.     }  
  33. //如果s == null，则说明上面在ubifs文件系统中没有找到，则需要创建超级块，这里申请内存。  
  34.     if (!s) {  
  35.         spin_unlock(&sb_lock);  
  36.         s = alloc_super(type, flags);  
  37.         if (!s)  
  38.             return ERR_PTR(-ENOMEM);  
  39.         goto retry;  
  40.     }  
  41. //调用set方法，为超级块设置一些内容。  
  42.     err = set(s, data);  
  43.     if (err) {  
  44.         spin_unlock(&sb_lock);  
  45.         up_write(&s->s_umount);  
  46.         destroy_super(s);  
  47.         return ERR_PTR(err);  
  48.     }  
  49. //对超级块的一些其它字段的初始化。  
  50.     s->s_type = type;  
  51.     strlcpy(s->s_id, type->name, sizeof(s->s_id));  
  52.     list_add_tail(&s->s_list, &super_blocks);  
  53.     hlist_add_head(&s->s_instances, &type->fs_supers);  
  54.     spin_unlock(&sb_lock);  
  55.     get_filesystem(type);  
  56.     register_shrinker(&s->s_shrink);  
  57.     return s;  
  58. }  

如果sb->s_root为null，则说明还没挂载，该超级块的内容需要从flash上读取。这个任务有ubifs_fill_super实现。

该函数的原型如下：

[cpp] view plain copy

  1. static int ubifs_fill_super(struct super_block *sb, void *data, int silent)  
  2. sb参数是先前创建的超级块，首先将超级块描述ubifs信息的字段单独取出来  
  3.     struct ubifs_info *c = sb->s_fs_info;  
  4.   
  5.     c->vfs_sb = sb;  
  6.     这里重新打开改UBI设备，注意权限编程的读写，这意味着需要从该设备读写数据了。  
  7.     c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READWRITE);  
  8.   
  9. 初始化相关字段，bdi是backing_dev_info简写，其功能是禁止预读，不需要改功能。  
  10.     c->bdi.name = "ubifs",  
  11.     c->bdi.capabilities = BDI_CAP_MAP_COPY;  
  12.     err  = bdi_init(&c->bdi);  
  13.     err = bdi_register(&c->bdi, NULL, "ubifs_%d_%d",  
  14.                c->vi.ubi_num, c->vi.vol_id);  
  15.   
  16.     err = ubifs_parse_options(c, data, 0);  
  17.     if (err)  
  18.         goto out_bdi;  
  19. //超级块信息初始化  
  20.     sb->s_bdi = &c->bdi;  
  21.     sb->s_fs_info = c;  
  22.     sb->s_magic = UBIFS_SUPER_MAGIC;  
  23.     sb->s_blocksize = UBIFS_BLOCK_SIZE;  
  24.     sb->s_blocksize_bits = UBIFS_BLOCK_SHIFT;  
  25.     sb->s_maxbytes = c->max_inode_sz = key_max_inode_size(c);  
  26.     if (c->max_inode_sz > MAX_LFS_FILESIZE)  
  27.         sb->s_maxbytes = c->max_inode_sz = MAX_LFS_FILESIZE;  
  28.     sb->s_op = &ubifs_super_operations;  
  29.   
  30.     mutex_lock(&c->umount_mutex);  
  31. //挂载ubifs文件系统。并调用ubifs_read_superblock读取超级块，使能日志功能等  
  32.     err = mount_ubifs(c);  
  33.       
  34.     /*读取根索引节点*/  
  35.     root = ubifs_iget(sb, UBIFS_ROOT_INO);  
  36. 将超级块和根索引节点关联  
  37.     sb->s_root = d_make_root(root);  

 

 

UBIFS文件系统的读写实际上就是UBI层到MTD层的一个过程，其读代码的执行流程如下，

由于在这篇文章里并不分析UBI和MTD层，所以这里只列出散布在UBIFS文件目录里的各个函数接口，其功能和关键实现代码在后续文章中再剖析。

UBIFS接口函数集

Makefile中显示的各个编译后目标的文件提供的函数接口如下：

[cpp] view plain copy

  1. /* io.c */  
  2. void ubifs_ro_mode(struct ubifs_info *c, int err);  
  3. int ubifs_leb_read(const struct ubifs_info *c, int lnum, void *buf, int offs,  
  4.            int len, int even_ebadmsg);  
  5. int ubifs_leb_write(struct ubifs_info *c, int lnum, const void *buf, int offs,  
  6.             int len);  
  7. int ubifs_leb_change(struct ubifs_info *c, int lnum, const void *buf, int len);  
  8. int ubifs_leb_unmap(struct ubifs_info *c, int lnum);  
  9. int ubifs_leb_map(struct ubifs_info *c, int lnum);  
  10. int ubifs_is_mapped(const struct ubifs_info *c, int lnum);  
  11. int ubifs_wbuf_write_nolock(struct ubifs_wbuf *wbuf, void *buf, int len);  
  12. int ubifs_wbuf_seek_nolock(struct ubifs_wbuf *wbuf, int lnum, int offs);  
  13. int ubifs_wbuf_init(struct ubifs_info *c, struct ubifs_wbuf *wbuf);  
  14. int ubifs_read_node(const struct ubifs_info *c, void *buf, int type, int len,  
  15.             int lnum, int offs);  
  16. int ubifs_read_node_wbuf(struct ubifs_wbuf *wbuf, void *buf, int type, int len,  
  17.              int lnum, int offs);  
  18. int ubifs_write_node(struct ubifs_info *c, void *node, int len, int lnum,  
  19.              int offs);  
  20. int ubifs_check_node(const struct ubifs_info *c, const void *buf, int lnum,  
  21.              int offs, int quiet, int must_chk_crc);  
  22. void ubifs_prepare_node(struct ubifs_info *c, void *buf, int len, int pad);  
  23. void ubifs_prep_grp_node(struct ubifs_info *c, void *node, int len, int last);  
  24. int ubifs_io_init(struct ubifs_info *c);  
  25. void ubifs_pad(const struct ubifs_info *c, void *buf, int pad);  
  26. int ubifs_wbuf_sync_nolock(struct ubifs_wbuf *wbuf);  
  27. int ubifs_bg_wbufs_sync(struct ubifs_info *c);  
  28. void ubifs_wbuf_add_ino_nolock(struct ubifs_wbuf *wbuf, ino_t inum);  
  29. int ubifs_sync_wbufs_by_inode(struct ubifs_info *c, struct inode *inode);  

 

 

[cpp] view plain copy

  1. /* scan.c */  
  2. struct ubifs_scan_leb *ubifs_scan(const struct ubifs_info *c, int lnum,  
  3.                   int offs, void *sbuf, int quiet);  
  4. void ubifs_scan_destroy(struct ubifs_scan_leb *sleb);  
  5. int ubifs_scan_a_node(const struct ubifs_info *c, void *buf, int len, int lnum,  
  6.               int offs, int quiet);  
  7. struct ubifs_scan_leb *ubifs_start_scan(const struct ubifs_info *c, int lnum,  
  8.                     int offs, void *sbuf);  
  9. void ubifs_end_scan(const struct ubifs_info *c, struct ubifs_scan_leb *sleb,  
  10.             int lnum, int offs);  
  11. int ubifs_add_snod(const struct ubifs_info *c, struct ubifs_scan_leb *sleb,  
  12.            void *buf, int offs);  
  13. void ubifs_scanned_corruption(const struct ubifs_info *c, int lnum, int offs,  
  14.                   void *buf);  


[cpp] view plain copy

  1. /* log.c */  
  2. void ubifs_add_bud(struct ubifs_info *c, struct ubifs_bud *bud);  
  3. void ubifs_create_buds_lists(struct ubifs_info *c);  
  4. int ubifs_add_bud_to_log(struct ubifs_info *c, int jhead, int lnum, int offs);  
  5. struct ubifs_bud *ubifs_search_bud(struct ubifs_info *c, int lnum);  
  6. struct ubifs_wbuf *ubifs_get_wbuf(struct ubifs_info *c, int lnum);  
  7. int ubifs_log_start_commit(struct ubifs_info *c, int *ltail_lnum);  
  8. int ubifs_log_end_commit(struct ubifs_info *c, int new_ltail_lnum);  
  9. int ubifs_log_post_commit(struct ubifs_info *c, int old_ltail_lnum);  
  10. int ubifs_consolidate_log(struct ubifs_info *c);  


[cpp] view plain copy

  1. /* journal.c */  
  2. int ubifs_jnl_update(struct ubifs_info *c, const struct inode *dir,  
  3.              const struct qstr *nm, const struct inode *inode,  
  4.              int deletion, int xent);  
  5. int ubifs_jnl_write_data(struct ubifs_info *c, const struct inode *inode,  
  6.              const union ubifs_key *key, const void *buf, int len);  
  7. int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode);  
  8. int ubifs_jnl_delete_inode(struct ubifs_info *c, const struct inode *inode);  
  9. int ubifs_jnl_rename(struct ubifs_info *c, const struct inode *old_dir,  
  10.              const struct dentry *old_dentry,  
  11.              const struct inode *new_dir,  
  12.              const struct dentry *new_dentry, int sync);  
  13. int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode,  
  14.                loff_t old_size, loff_t new_size);  
  15. int ubifs_jnl_delete_xattr(struct ubifs_info *c, const struct inode *host,  
  16.                const struct inode *inode, const struct qstr *nm);  
  17. int ubifs_jnl_change_xattr(struct ubifs_info *c, const struct inode *inode1,  
  18.                const struct inode *inode2);  




[cpp] view plain copy

  1. /* budget.c */  
  2. int ubifs_budget_space(struct ubifs_info *c, struct ubifs_budget_req *req);  
  3. void ubifs_release_budget(struct ubifs_info *c, struct ubifs_budget_req *req);  
  4. void ubifs_release_dirty_inode_budget(struct ubifs_info *c,  
  5.                       struct ubifs_inode *ui);  
  6. int ubifs_budget_inode_op(struct ubifs_info *c, struct inode *inode,  
  7.               struct ubifs_budget_req *req);  
  8. void ubifs_release_ino_dirty(struct ubifs_info *c, struct inode *inode,  
  9.                 struct ubifs_budget_req *req);  
  10. void ubifs_cancel_ino_op(struct ubifs_info *c, struct inode *inode,  
  11.              struct ubifs_budget_req *req);  
  12. long long ubifs_get_free_space(struct ubifs_info *c);  
  13. long long ubifs_get_free_space_nolock(struct ubifs_info *c);  
  14. int ubifs_calc_min_idx_lebs(struct ubifs_info *c);  
  15. void ubifs_convert_page_budget(struct ubifs_info *c);  
  16. long long ubifs_reported_space(const struct ubifs_info *c, long long free);  
  17. long long ubifs_calc_available(const struct ubifs_info *c, int min_idx_lebs);  




[cpp] view plain copy

  1. /* find.c */  
  2. int ubifs_find_free_space(struct ubifs_info *c, int min_space, int *offs,  
  3.               int squeeze);  
  4. int ubifs_find_free_leb_for_idx(struct ubifs_info *c);  
  5. int ubifs_find_dirty_leb(struct ubifs_info *c, struct ubifs_lprops *ret_lp,  
  6.              int min_space, int pick_free);  
  7. int ubifs_find_dirty_idx_leb(struct ubifs_info *c);  
  8. int ubifs_save_dirty_idx_lnums(struct ubifs_info *c);  




[cpp] view plain copy

  1. /* tnc.c */  
  2. int ubifs_lookup_level0(struct ubifs_info *c, const union ubifs_key *key,  
  3.             struct ubifs_znode **zn, int *n);  
  4. int ubifs_tnc_lookup_nm(struct ubifs_info *c, const union ubifs_key *key,  
  5.             void *node, const struct qstr *nm);  
  6. int ubifs_tnc_locate(struct ubifs_info *c, const union ubifs_key *key,  
  7.              void *node, int *lnum, int *offs);  
  8. int ubifs_tnc_add(struct ubifs_info *c, const union ubifs_key *key, int lnum,  
  9.           int offs, int len);  
  10. int ubifs_tnc_replace(struct ubifs_info *c, const union ubifs_key *key,  
  11.               int old_lnum, int old_offs, int lnum, int offs, int len);  
  12. int ubifs_tnc_add_nm(struct ubifs_info *c, const union ubifs_key *key,  
  13.              int lnum, int offs, int len, const struct qstr *nm);  
  14. int ubifs_tnc_remove(struct ubifs_info *c, const union ubifs_key *key);  
  15. int ubifs_tnc_remove_nm(struct ubifs_info *c, const union ubifs_key *key,  
  16.             const struct qstr *nm);  
  17. int ubifs_tnc_remove_range(struct ubifs_info *c, union ubifs_key *from_key,  
  18.                union ubifs_key *to_key);  
  19. int ubifs_tnc_remove_ino(struct ubifs_info *c, ino_t inum);  
  20. struct ubifs_dent_node *ubifs_tnc_next_ent(struct ubifs_info *c,  
  21.                        union ubifs_key *key,  
  22.                        const struct qstr *nm);  
  23. void ubifs_tnc_close(struct ubifs_info *c);  
  24. int ubifs_tnc_has_node(struct ubifs_info *c, union ubifs_key *key, int level,  
  25.                int lnum, int offs, int is_idx);  
  26. int ubifs_dirty_idx_node(struct ubifs_info *c, union ubifs_key *key, int level,  
  27.              int lnum, int offs);  
  28. /* Shared by tnc.c for tnc_commit.c */  
  29. void destroy_old_idx(struct ubifs_info *c);  
  30. int is_idx_node_in_tnc(struct ubifs_info *c, union ubifs_key *key, int level,  
  31.                int lnum, int offs);  
  32. int insert_old_idx_znode(struct ubifs_info *c, struct ubifs_znode *znode);  
  33. int ubifs_tnc_get_bu_keys(struct ubifs_info *c, struct bu_info *bu);  
  34. int ubifs_tnc_bulk_read(struct ubifs_info *c, struct bu_info *bu);  



[cpp] view plain copy

  1. /* tnc_misc.c */  
  2. struct ubifs_znode *ubifs_tnc_levelorder_next(struct ubifs_znode *zr,  
  3.                           struct ubifs_znode *znode);  
  4. int ubifs_search_zbranch(const struct ubifs_info *c,  
  5.              const struct ubifs_znode *znode,  
  6.              const union ubifs_key *key, int *n);  
  7. struct ubifs_znode *ubifs_tnc_postorder_first(struct ubifs_znode *znode);  
  8. struct ubifs_znode *ubifs_tnc_postorder_next(struct ubifs_znode *znode);  
  9. long ubifs_destroy_tnc_subtree(struct ubifs_znode *zr);  
  10. struct ubifs_znode *ubifs_load_znode(struct ubifs_info *c,  
  11.                      struct ubifs_zbranch *zbr,  
  12.                      struct ubifs_znode *parent, int iip);  
  13. int ubifs_tnc_read_node(struct ubifs_info *c, struct ubifs_zbranch *zbr,  
  14.             void *node);  


[cpp] view plain copy

  1. /* tnc_commit.c */  
  2. int ubifs_tnc_start_commit(struct ubifs_info *c, struct ubifs_zbranch *zroot);  
  3. int ubifs_tnc_end_commit(struct ubifs_info *c);  
  4.   
  5. /* shrinker.c */  
  6. int ubifs_shrinker(struct shrinker *shrink, struct shrink_control *sc);  
  7.   
  8. /* commit.c */  
  9. int ubifs_bg_thread(void *info);  
  10. void ubifs_commit_required(struct ubifs_info *c);  
  11. void ubifs_request_bg_commit(struct ubifs_info *c);  
  12. int ubifs_run_commit(struct ubifs_info *c);  
  13. void ubifs_recovery_commit(struct ubifs_info *c);  
  14. int ubifs_gc_should_commit(struct ubifs_info *c);  
  15. void ubifs_wait_for_commit(struct ubifs_info *c);  
  16.   
  17. /* master.c */  
  18. int ubifs_read_master(struct ubifs_info *c);  
  19. int ubifs_write_master(struct ubifs_info *c);  
  20.   
  21. /* sb.c */  
  22. int ubifs_read_superblock(struct ubifs_info *c);  
  23. struct ubifs_sb_node *ubifs_read_sb_node(struct ubifs_info *c);  
  24. int ubifs_write_sb_node(struct ubifs_info *c, struct ubifs_sb_node *sup);  
  25. int ubifs_fixup_free_space(struct ubifs_info *c);  
  26.   
  27. /* replay.c */  
  28. int ubifs_validate_entry(struct ubifs_info *c,  
  29.              const struct ubifs_dent_node *dent);  
  30. int ubifs_replay_journal(struct ubifs_info *c);  
  31.   
  32. /* gc.c */  
  33. int ubifs_garbage_collect(struct ubifs_info *c, int anyway);  
  34. int ubifs_gc_start_commit(struct ubifs_info *c);  
  35. int ubifs_gc_end_commit(struct ubifs_info *c);  
  36. void ubifs_destroy_idx_gc(struct ubifs_info *c);  
  37. int ubifs_get_idx_gc_leb(struct ubifs_info *c);  
  38. int ubifs_garbage_collect_leb(struct ubifs_info *c, struct ubifs_lprops *lp);  
  39.   
  40. /* orphan.c */  
  41. int ubifs_add_orphan(struct ubifs_info *c, ino_t inum);  
  42. void ubifs_delete_orphan(struct ubifs_info *c, ino_t inum);  
  43. int ubifs_orphan_start_commit(struct ubifs_info *c);  
  44. int ubifs_orphan_end_commit(struct ubifs_info *c);  
  45. int ubifs_mount_orphans(struct ubifs_info *c, int unclean, int read_only);  
  46. int ubifs_clear_orphans(struct ubifs_info *c);  


[cpp] view plain copy

  1. /* lpt.c */  
  2. int ubifs_calc_lpt_geom(struct ubifs_info *c);  
  3. int ubifs_create_dflt_lpt(struct ubifs_info *c, int *main_lebs, int lpt_first,  
  4.               int *lpt_lebs, int *big_lpt);  
  5. int ubifs_lpt_init(struct ubifs_info *c, int rd, int wr);  
  6. struct ubifs_lprops *ubifs_lpt_lookup(struct ubifs_info *c, int lnum);  
  7. struct ubifs_lprops *ubifs_lpt_lookup_dirty(struct ubifs_info *c, int lnum);  
  8. int ubifs_lpt_scan_nolock(struct ubifs_info *c, int start_lnum, int end_lnum,  
  9.               ubifs_lpt_scan_callback scan_cb, void *data);  
  10.   
  11. /* Shared by lpt.c for lpt_commit.c */  
  12. void ubifs_pack_lsave(struct ubifs_info *c, void *buf, int *lsave);  
  13. void ubifs_pack_ltab(struct ubifs_info *c, void *buf,  
  14.              struct ubifs_lpt_lprops *ltab);  
  15. void ubifs_pack_pnode(struct ubifs_info *c, void *buf,  
  16.               struct ubifs_pnode *pnode);  
  17. void ubifs_pack_nnode(struct ubifs_info *c, void *buf,  
  18.               struct ubifs_nnode *nnode);  
  19. struct ubifs_pnode *ubifs_get_pnode(struct ubifs_info *c,  
  20.                     struct ubifs_nnode *parent, int iip);  
  21. struct ubifs_nnode *ubifs_get_nnode(struct ubifs_info *c,  
  22.                     struct ubifs_nnode *parent, int iip);  
  23. int ubifs_read_nnode(struct ubifs_info *c, struct ubifs_nnode *parent, int iip);  
  24. void ubifs_add_lpt_dirt(struct ubifs_info *c, int lnum, int dirty);  
  25. void ubifs_add_nnode_dirt(struct ubifs_info *c, struct ubifs_nnode *nnode);  
  26. uint32_t ubifs_unpack_bits(uint8_t **addr, int *pos, int nrbits);  
  27. struct ubifs_nnode *ubifs_first_nnode(struct ubifs_info *c, int *hght);  
  28. /* Needed only in debugging code in lpt_commit.c */  
  29. int ubifs_unpack_nnode(const struct ubifs_info *c, void *buf,  
  30.                struct ubifs_nnode *nnode);  
  31.   
  32. /* lpt_commit.c */  
  33. int ubifs_lpt_start_commit(struct ubifs_info *c);  
  34. int ubifs_lpt_end_commit(struct ubifs_info *c);  
  35. int ubifs_lpt_post_commit(struct ubifs_info *c);  
  36. void ubifs_lpt_free(struct ubifs_info *c, int wr_only);  
  37.   
  38. /* lprops.c */  
  39. const struct ubifs_lprops *ubifs_change_lp(struct ubifs_info *c,  
  40.                        const struct ubifs_lprops *lp,  
  41.                        int free, int dirty, int flags,  
  42.                        int idx_gc_cnt);  
  43. void ubifs_get_lp_stats(struct ubifs_info *c, struct ubifs_lp_stats *lst);  
  44. void ubifs_add_to_cat(struct ubifs_info *c, struct ubifs_lprops *lprops,  
  45.               int cat);  
  46. void ubifs_replace_cat(struct ubifs_info *c, struct ubifs_lprops *old_lprops,  
  47.                struct ubifs_lprops *new_lprops);  
  48. void ubifs_ensure_cat(struct ubifs_info *c, struct ubifs_lprops *lprops);  
  49. int ubifs_categorize_lprops(const struct ubifs_info *c,  
  50.                 const struct ubifs_lprops *lprops);  
  51. int ubifs_change_one_lp(struct ubifs_info *c, int lnum, int free, int dirty,  
  52.             int flags_set, int flags_clean, int idx_gc_cnt);  
  53. int ubifs_update_one_lp(struct ubifs_info *c, int lnum, int free, int dirty,  
  54.             int flags_set, int flags_clean);  
  55. int ubifs_read_one_lp(struct ubifs_info *c, int lnum, struct ubifs_lprops *lp);  
  56. const struct ubifs_lprops *ubifs_fast_find_free(struct ubifs_info *c);  
  57. const struct ubifs_lprops *ubifs_fast_find_empty(struct ubifs_info *c);  
  58. const struct ubifs_lprops *ubifs_fast_find_freeable(struct ubifs_info *c);  
  59. const struct ubifs_lprops *ubifs_fast_find_frdi_idx(struct ubifs_info *c);  
  60. int ubifs_calc_dark(const struct ubifs_info *c, int spc);  


[cpp] view plain copy

  1. /* file.c */  
  2. int ubifs_fsync(struct file *file, loff_t start, loff_t end, int datasync);  
  3. int ubifs_setattr(struct dentry *dentry, struct iattr *attr);  
  4.   
  5. /* dir.c */  
  6. struct inode *ubifs_new_inode(struct ubifs_info *c, const struct inode *dir,  
  7.                   umode_t mode);  
  8. int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry,  
  9.           struct kstat *stat);  
  10.   
  11. /* xattr.c */  
  12. int ubifs_setxattr(struct dentry *dentry, const char *name,  
  13.            const void *value, size_t size, int flags);  
  14. ssize_t ubifs_getxattr(struct dentry *dentry, const char *name, void *buf,  
  15.                size_t size);  
  16. ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size);  
  17. int ubifs_removexattr(struct dentry *dentry, const char *name);  
  18.   
  19. /* super.c */  
  20. struct inode *ubifs_iget(struct super_block *sb, unsigned long inum);  
  21.   
  22. /* recovery.c */  
  23. int ubifs_recover_master_node(struct ubifs_info *c);  
  24. int ubifs_write_rcvrd_mst_node(struct ubifs_info *c);  
  25. struct ubifs_scan_leb *ubifs_recover_leb(struct ubifs_info *c, int lnum,  
  26.                      int offs, void *sbuf, int jhead);  
  27. struct ubifs_scan_leb *ubifs_recover_log_leb(struct ubifs_info *c, int lnum,  
  28.                          int offs, void *sbuf);  
  29. int ubifs_recover_inl_heads(struct ubifs_info *c, void *sbuf);  
  30. int ubifs_clean_lebs(struct ubifs_info *c, void *sbuf);  
  31. int ubifs_rcvry_gc_commit(struct ubifs_info *c);  
  32. int ubifs_recover_size_accum(struct ubifs_info *c, union ubifs_key *key,  
  33.                  int deletion, loff_t new_size);  
  34. int ubifs_recover_size(struct ubifs_info *c);  
  35. void ubifs_destroy_size_tree(struct ubifs_info *c);  
  36.   
  37. /* ioctl.c */  
  38. long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);  
  39. void ubifs_set_inode_flags(struct inode *inode);  
  40. #ifdef CONFIG_COMPAT  
  41. long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);  
  42. #endif  
  43.   
  44. /* compressor.c */  
  45. int __init ubifs_compressors_init(void);  
  46. void ubifs_compressors_exit(void);  
  47. void ubifs_compress(const void *in_buf, int in_len, void *out_buf, int *out_len,  
  48.             int *compr_type);  
  49. int ubifs_decompress(const void *buf, int len, void *out, int *out_len,  
  50.              int compr_type);  
标签
ubifs
索引
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!