ubi源代码分析

小咪咪 2021-12-12 13:53 1443阅读 0赞

原文网址：[ubi源代码分析\_IT利刃出鞘的博客-CSDN博客][ubi_IT_-CSDN]

本文分析的版本是：mtd-utils-1.5.1，内核版本linux-4.9.37

# 相关网站 #

[mtd-utils官网][mtd-utils] [mtd-utils下载地址][mtd-utils 1] [mtd-utils版本差异][mtd-utils 2]

# ubi的读写流程 #

函数位置：io.c(drivers/mtd/ubi)

## 坏块检查 ##

ubi\_io\_is\_bad(ubi, pnum); //io.c (drivers/mtd/ubi)  
mtd\_block\_isbad(mtd, (loff\_t)pnum \* ubi->peb\_size); //mtdcore.c  
mtd->\_block\_isbad(mtd, ofs); //nand\_base.c =>nand\_scan\_tail指定  
nand\_block\_isbad(mtd, ofs) //nand\_base.c  
chip->select\_chip(mtd, chipnr);  
nand\_block\_checkbad(mtd, offs, 0); //nand\_base.c  
若指定了chip->bbt //否则nand\_isbad\_bbt(mtd, ofs, allowbbt); //nand\_bbt.c  
chip->block\_bad(mtd, ofs);  
//nand\_base.c=> nand\_scan\_ident=> nand\_set\_defaults  
nand\_block\_bad(mtd, ofs) //nand\_base.c  
如果(chip->bbt\_options & NAND\_BBT\_SCANLASTPAGE)  
ofs += mtd->erasesize - mtd->writesize;  
chip->cmdfunc(mtd, NAND\_CMD\_READOOB, chip->badblockpos, page);  
bad = chip->read\_byte(mtd);  
res = bad != 0xFF;  
如果(chip->bbt\_options & NAND\_BBT\_SCAN2NDPAGE)  
会再读下一页的bb数据  
return res;

## 读 ##

ubi\_io\_read(const struct ubi\_device \*ubi, void \*buf, int pnum, int offset, int len) //io.c(drivers/mtd/ubi)  
dbg\_io("read %d bytes from PEB %d:%d", len, pnum, offset);  
self\_check\_not\_bad(ubi, pnum); //io.c (drivers/mtd/ubi)  
err = ubi\_io\_is\_bad(ubi, pnum);  
err = mtd\_read(ubi->mtd, addr, len, &read, buf); //mtdcore.c  
//详细流程见[mtd读流程][mtd]  
如果err是-UCLEAN  
打印：ubi\_msg(ubi, "fixable bit-flip detected at PEB %d", pnum);  
return UBI\_IO\_BITFLIPS;  
如果传输次数小于3  
打印：ubi\_warn(ubi, "error %d%s while reading %d bytes from PEB %d:%d, read only %zd bytes, retry",  
err, errstr, len, pnum, offset, read);  
重传  
//到此，说明传输失败  
打印：ubi\_err(ubi, "error %d%s while reading %d bytes from PEB %d:%d, read %zd bytes",  
err, errstr, len, pnum, offset, read);  
dump\_stack();  
如果读的长度不正确而且发生了ECC错误（返回值是-EBADMSG）  
返回-EIO

## 写 ##

ubi\_io\_write(struct ubi\_device \*ubi, const void \*buf, int pnum, int offset, int len) //io.c(drivers/mtd/ubi)  
self\_check\_not\_bad(ubi, pnum); //io.c (drivers/mtd/ubi)  
err = ubi\_io\_is\_bad(ubi, pnum);  
/\* 一般不走此分支。检查要写的地方是不是都是0xff。  
\* 本部分只有手动把debug文件系统的ubi/ubiN/chk\_io写为非0才会调用到。  
\*/  
ubi\_self\_check\_all\_ff(ubi, pnum, offset, len); //io.c (drivers/mtd/ubi)  
err = mtd\_read(ubi->mtd, addr, len, &read, buf); //mtdcore.c  
//详细流程见 [mtd写流程][mtd 1]  
如果err不是0,且值不是-EUCLEAN（bitflip）  
打印错误，返回err  
//判断是否都是0xff  
err = ubi\_check\_pattern(buf, 0xFF, len); //misc.c (drivers/mtd/ubi)  
如果不都是0xff  
ubi\_err(ubi, "flash region at PEB %d:%d, length %d does not contain all 0xFF bytes",  
pnum, offset, len);  
ubi\_err(ubi, "self-check failed for PEB %d", pnum);  
ubi\_msg(ubi, "hex dump of the %d-%d region", offset, offset + len);  
print\_hex\_dump(KERN\_DEBUG, "", DUMP\_PREFIX\_OFFSET, 32, 1, buf, len, 1);  
如果偏移值大于leb\_start  
检查EC header，VID header  
err = mtd\_write(ubi->mtd, addr, len, &written, buf); //mtdcore.c  
//详细流程见mtd写流程  
如果err为0  
/\* 一般不走此分支。读出写进去的数据，确保和写的数据是一样的  
\* 本部分只有手动把debug文件系统的ubi/ubiN/chk\_io写为非0才会调用到。  
\*/  
self\_check\_write(ubi, buf, pnum, offset, len); //io.c (drivers/mtd/ubi)  
mtd\_read(ubi->mtd, addr, len, &read, buf1)  
把读出的数据与原先数据比较  
如果之前写没有写满一个peb  
/\* 一般不走此分支。检查之后的数据是否都是0xff  
\* 本部分只有手动把debug文件系统的ubi/ubiN/chk\_io写为非0才会调用到。  
\*/  
ubi\_self\_check\_all\_ff(ubi, pnum, offset, len);

# ubi初始化 #

build.c (drivers/mtd/ubi)  
ubi\_init  
class\_register(&ubi\_class);  
//在/sys/class路径之下创建ubi文件夹  
misc\_register(&ubi\_ctrl\_cdev); //ubi/cdev.c : ubi\_ctrl\_cdev.fops = &**ubi\_ctrl\_cdev\_operations**  
//创建/dev/ubi\_ctrl设备  
ubiblock\_init() //drivers/mtd/ubi/block.c  
ubiblock\_major = register\_blkdev(0, "ubiblock");  
ubiblock\_create\_from\_param();  
// 注册volume notifier：当volume被创建、删除、修改大小、修改名字或者更新时会调用到nb->notifier\_call()  
ubi\_register\_volume\_notifier(&ubiblock\_notifier, 1); //kapi.c ubiblock\_notifier在block.c中定义  
//传进来的参数为 nb  
//BLOCKING\_NOTIFIER\_HEAD(ubi\_notifiers); //kapi.c  
blocking\_notifier\_chain\_register(&ubi\_notifiers, nb); //kernel/notifier.c  
//第一个参数为nh，第二个为n  
notifier\_chain\_register(&nh->head, n);  
找到nh->head的最后一个或者n的优先级比nh->head高的  
n->next = nh->head //ubiblock\_notifier->next = ubi\_notifiers->head  
ubi\_enumerate\_volumes(nb);  
//传进来的参数为nb  
对于所有存在的struct ubi\_device \*ubi，调用  
ubi\_notify\_all(ubi, UBI\_VOLUME\_ADDED, nb);  
进行ubi->vtbl\_slots次以下操作  
调用nb->notifier\_call(nb, ntype, &nt);  
ubiblock\_notifier->notifier\_call 即：ubiblock\_notify  
判断ntype，进行add或remove或resize等操作  
add操作：什么都不做。（因为强制执行明确的块设备的创建）

# ubiformat #

操作的节点是/dev/mtdN，对应ubi/cdev.c=> **ubi\_ctrl\_cdev\_operations**

ubiformat.c=> main  
libmtd\_t libmtd;  
struct mtd\_info mtd\_info  
libmtd\_open  
lib->sysfs\_supported = 1;  
libmtd \*lib;  
lib->sysfs\_mtd = "/sys/class/mtd"  
parse\_opt  
解析参数  
mtd\_get\_info(libmtd, &mtmtd\_get\_info(libmtd, &mtd\_info);  
读/sys/class/mtd下符合mtd%d%s的目录  
设置mtd\_info->mtd\_dev\_cnt，mtd\_info->highest\_mtd\_num，mtd\_info->lowest\_mtd\_num  
mtd\_get\_dev\_info(libmtd, args.node, &mtd)  
通过节点转化为设备号  
mtd\_get\_dev\_info1(desc, mtd\_num, mtd)  
从/sys/class/mtd/mtdN/节点中获得erasesize,writesize等  
libubi\_open  
//检查是不是已经attach了，如果已经attach，则以下所有节点都会有，导致返回非NULL  
lib->sysfs\_ctrl = /sys/class/misc/ubi\_ctrl/  
lib->ctrl\_dev = /sys/class/misc/ubi\_ctrl/dev  
lib->sysfs\_ubi = /sys/class/ubi  
lib->ubi\_dev = /sys/class/ubi/ubiN  
lib->ubi\_version = /sys/class/ubi/version  
lib->dev\_dev = /sys/class/ubi/ubiN/dev  
lib->dev\_avail\_ebs = /sys/class/ubi/ubiN/avail\_eraseblocks  
下边简写，都是lib->xxx = /sys/class/ubi/ubiN/xxx  
dev\_total\_ebs = total\_eraseblocks  
...  
max\_vol\_count =  
dev\_mtd\_num  
ubi\_vol  
vol\_type  
vol\_dev  
vol\_alignment  
...  
ubi\_scan(&mtd, args.node\_fd, &si, verbose)  
//扫描可擦除块  
分配1个struct ubi\_scan\_info，分配eraseblock count个32字节，存erase count  
对于每个块  
分配1个struct ubi\_scan\_info，分配eraseblock count个32字节，存erase count  
//**是坏块则跳过；记录坏块数**  
 ioctl(fd, MEMGETBADBLOCK, &seek);  
mtdchar\_unlocked\_ioctl //mtdchar.c  
mtdchar\_ioctl(file, cmd, arg); //mtdchar.c  
mtd\_block\_isbad(mtd, offs); //mtdcore.c  
mtd->\_block\_isbad(mtd, ofs);  
//nand\_base.c=> nand\_scan\_tail指定  
nand\_block\_isbad(mtd, ofs); //nand\_base.c  
chip->select\_chip(mtd, chipnr);  
nand\_block\_checkbad(mtd, offs, 0); //nand\_base.c  
//nand\_base.c  
if (!chip->bbt)  
chip->block\_bad(mtd, ofs);  
nand\_block\_bad(mtd,ofs) //nand\_base.c  
/\* nand\_base.c=>  
\* nand\_scan\_ident =>  
\* nand\_set\_default指定  
\*/  
否则  
nand\_isbad\_bbt(mtd, ofs, allowbbt);  
//nand\_bbt.c  
  
//**读出EC header**  
mtd\_read(mtd, fd, eb, 0, &ech, sizeof(struct ubi\_ec\_hdr)  
ret = read(fd, buf, len); //调用到mtdchar.c => mtdchar\_read （mtd\_fops）  
如果读出来的EC header都是0xff，则相应块的EC置为EB\_EMPTY（0xFFFFFFFF）  
否则，相应块的EC置为EB\_ALIEN（0xFFFFFFFD）  
进行数据校验  
如果校验失败，则把相应块的EC置为EB\_CORRUPTED（0xFFFFFFFE）  
记录EC  
如果是第一次格式化  
若data\_offset对min\_io\_size取余有余数，说明出错了，  
相应块的EC置为EB\_CORRUPTED（0xFFFFFFFE）  
计算好块、坏块、空块、平均擦除次数等  
ubigen\_info\_init  
 **ui->peb\_size = peb\_size;**  
调整data\_offs为min\_io\_size整数倍  
**ui->leb\_size = peb\_size - ui->data\_offs**  
ui->max\_volumes = ui->leb\_size / UBI\_VTBL\_RECORD\_SIZE  
（\#define UBI\_VTBL\_RECORD\_SIZE sizeof(struct ubi\_vtbl\_record)  
ui->vtbl\_size = ui->max\_volumes \* UBI\_VTBL\_RECORD\_SIZE;  
  
如果指定了-f参数（image文件）  
flash\_image  
先擦后写  
format  
否则  
format  
**对于所有的eraseblock**  
如果是坏块，则跳过（是否是坏块已经在ubi\_scan函数中读出了）  
EC自加1  
设置EC header  
**擦除 //底层会先检查是否是坏块再擦除**  
 **如果擦除失败，标记为坏块**（通过ioctl(fd, MEMSETBADBLOCK, ...）  
eb1 = 0 //eb1也就是peb0（**flash第0块**）  
ec1 = 第0块的擦除次数  
eb2 = 1 //eb2也就是peb1（**flash第1块**）  
ec2 = 第1块的擦除次数  
**写入一页（只写EC header）  
如果写失败了，进行torture**  
/\* 擦除=> 检查是否都是0xff => 写入测试数据 => 读出测试数据 => 检查读出和写入的是否相同  
\* 测试数据是0xa5,0x5a,0x00。一共测试三次，第一次以0xa5测试，第二次以0x5a，  
\* 第三次以0x00测试，一旦检查结果是不一样，则标记为坏块。  
\*/  
如果没有指定-n参数  
vtbl = ubigen\_create\_empty\_vtbl(ui)  
struct ubi\_vtbl\_record \*vtbl;  
vtbl = 分配ui->vtbl\_size大小空间并初始化为0  
对于ui->max\_volumes个struct ubi\_vtbl\_record，计算其mtd\_crc值，赋值给分配的那个空间  
  
ubigen\_write\_layout\_vol(ui, eb1, eb2, ec1, ec2, vtbl, args.node\_fd);  
struct ubigen\_vol\_info vi;  
vi.type = UBI\_LAYOUT\_VOLUME\_TYPE;  
//\#define UBI\_LAYOUT\_VOLUME\_TYPE UBI\_VID\_DYNAMIC  
vi.name = UBI\_LAYOUT\_VOLUME\_NAME;  
//\#define UBI\_LAYOUT\_VOLUME\_NAME "layout volume"  
outbuf = 分配一个peb空间  
  
把outbuf置为0xff  
拷贝vtbl为首地址，ui->vtbl\_size为长度的数据到outbuf + ui->data\_offs的位置  
把outbuf + ui->data\_offs + ui->vtbl\_size之后的数据置为0xff  
  
初始化eb1的EC header  
初始化eb1的VID header(lnum = 0, data\_size = 0)  
**把outbuf数据写到flash中（所在分区第0个块），长度为一个peb**  
  
初始化eb2的EC header  
初始化eb2的VID header(lnum = 1, data\_size = 0)  
**把outbuf数据写到flash中（所在分区第1个块），长度为一个peb**

# ubiattach #

## ubiattach应用层 ##

ubiattach.c => main

static struct args args = \{  
.devn = UBI\_DEV\_NUM\_AUTO,  
.mtdn = -1,  
.vidoffs = 0,  
.node = NULL,  
.dev = NULL,  
.max\_beb\_per1024 = 0,  
\};

libubi\_t libubi;  
parse\_opt(argc, argv);  
args.node = DEFAULT\_CTRL\_DEV; //\#define DEFAULT\_CTRL\_DEV "/dev/ubi\_ctrl"  
case 'd':  
**args.devn = simple\_strtoul(optarg, &error);**  
case 'm':  
**args.mtdn = simple\_strtoul(optarg, &error);**  
libubi\_open  
组合/sys/class/相关路径  
  
ubi\_get\_info(libubi, &ubi\_info)  
read\_major(lib->ctrl\_dev, &info->ctrl\_major, &info->ctrl\_minor)  
  
req.dev\_num = args.devn;  
req.mtd\_num = args.mtdn;  
req.mtd\_dev\_node = args.dev;  
req.vid\_hdr\_offset = args.vidoffs;  
//max\_beb\_per1024: Maximum expected bad eraseblocks per 1024 eraseblocks  
req.max\_beb\_per1024 = args.max\_beb\_per1024;  
  
ubi\_attach(libubi, args.node, &req);  
r.ubi\_num = req->dev\_num;  
r.mtd\_num = req->mtd\_num;  
r.vid\_hdr\_offset = req->vid\_hdr\_offset;  
r.max\_beb\_per1024 = req->max\_beb\_per1024;  
do\_attach(node, &r);  
fd = open(node, O\_RDONLY);  
 **ioctl(fd, UBI\_IOCATT, r);**  
  
//attach操作结束后，获得相关信息并打印  
ubi\_get\_dev\_info1(libubi, req.dev\_num, &dev\_info)  
打印：UBI device number %d, total %d LEBs (  
), available %d LEBs (  
), LEB size

## ubiattach底层 ##

**ioctl(fd, UBI\_IOCATT, r)**  
ctrl\_cdev\_ioctl //drivers/mtd/ubi/cdev.c  
struct ubi\_attach\_req req;  
struct mtd\_info \*mtd;  
copy\_from\_user(&req, argp, sizeof(struct ubi\_attach\_req));  
mtd = get\_mtd\_device(NULL, req.mtd\_num);  
ubi\_attach\_mtd\_dev(mtd, req.ubi\_num, req.vid\_hdr\_offset, req.max\_beb\_per1024); //build.c (drivers/mtd/ubi)  
max\_beb\_per1024 = CONFIG\_MTD\_UBI\_BEB\_LIMIT;  
/\* 20 在make menuconfig时配置的：  
\* Device Drivers=> Memory Technology Device (MTD) support =>  
\* Enable UBI - Unsorted block images =>  
\* Maximum expected bad eraseblock count per 1024 eraseblocks  
\*/  
已经attach则退出  
**ubi = kzalloc(sizeof(struct ubi\_device), GFP\_KERNEL);**  
**ubi->mtd = mtd;**  
 **ubi->ubi\_num = ubi\_num;**  
打印ubiN : attaching mtd%d  
io\_init(ubi, max\_beb\_per1024); //ioc (drivers/mtd/ubi)  
**ubi->bad\_allowed = 1**;  
ubi->bad\_peb\_limit = get\_bad\_peb\_limit(ubi, max\_beb\_per1024);  
ubi->min\_io\_size = ubi->mtd->writesize;  
ubi\_attach(ubi, 0) //attach.c (drivers/mtd/ubi)  
struct ubi\_attach\_info \*ai;  
ai = alloc\_ai();  
scan\_all(ubi, ai, 0); //attach.c (drivers/mtd/ubi)  
对每一个peb  
scan\_peb(ubi, ai, pnum, false) //attach.c (drivers/mtd/ubi)  
//**跳过坏块（是坏块直接返回（没使用坏块表，则读bb区））**  
err = mtd\_block\_isbad(mtd, (loff\_t)pnum \* ubi->peb\_size);  
ret = mtd\_block\_isbad(mtd, (loff\_t)pnum \* ubi->peb\_size);  
mtd->\_block\_isbad(mtd, ofs); //nand\_base.c =>nand\_scan\_tail指定  
nand\_block\_isbad(mtd, ofs) //nand\_base.c  
chip->select\_chip(mtd, chipnr);  
nand\_block\_checkbad(mtd, offs, 0); //nand\_base.c  
若指定了chip->bbt //  
chip->block\_bad(mtd, ofs);  
//nand\_base.c=> nand\_scan\_ident=> nand\_set\_defaults  
nand\_block\_bad(mtd, ofs) //nand\_base.c  
否则  
nand\_isbad\_bbt(mtd, ofs, allowbbt); //nand\_bbt.c  
//**读EC header （所有块）**  
err = ubi\_io\_read\_ec\_hdr(ubi, pnum, ech, 0) //io.c(drivers/mtd/ubi)  
read\_err = ubi\_io\_read(ubi, ec\_hdr, pnum, 0, UBI\_EC\_HDR\_SIZE)  
//io.c(drivers/mtd/ubi)  
err = mtd\_read(ubi->mtd, addr, len, &read, buf) //mtdcore.c  
//之后的流程见 [mtd读流程 ][mtd]

read\_err值：0、UBI\_IO\_BITFLIPS、-EBADMSG等  
如果err<0；直接返回  
如果err是UBI\_IO\_BITFLIPS：bitflips = 1;  
如果err是UBI\_IO\_FF：ai->empty\_peb\_count += 1;  
return add\_to\_list(ai, pnum, UBI\_UNKNOWN, ...，0, &ai->erase);  
如果err是UBI\_IO\_FF\_BITFLIPS：ai->empty\_peb\_count += 1;  
return add\_to\_list(ai, pnum, UBI\_UNKNOWN,..,1, &ai->erase);  
如果EC大于0x7fffffff，打印错误信息，返回  
**读VID header（所有块）**  
若读出的vol\_id大于UBI\_MAX\_VOLUMES而且不是布局卷  
说明有问题，进行处理

如果是Fastmap volume（判断方法：若vol\_id是  
UBI\_MAX\_VOLUMES（UBI\_LAYOUT\_VOLUME\_ID + 1)或  
UBI\_FM\_DATA\_VOLUME\_ID（UBI\_LAYOUT\_VOLUME\_ID+2）则是）  
分配struct ubi\_ainf\_peb并把它加到fastmap的list  
否则  
//把本peb添加到相关volume的used tree  
ubi\_add\_to\_av(ubi, ai, pnum, ec, vidh, bitflips) //attach.c (drivers/mtd/ubi)  
struct ubi\_ainf\_peb \*aeb;  
struct ubi\_ainf\_volume \*av;  
struct rb\_node \*\*p

lnum = be32\_to\_cpu(vid\_hdr->lnum);  
vol\_id = be32\_to\_cpu(vid\_hdr->vol\_id);  
av = add\_volume(ai, vol\_id, pnum, vid\_hdr)  
ubi\_find\_or\_add\_av(ai, vol\_id, &created);  
find\_or\_add\_av(ai, vol\_id, AV\_FIND\_OR\_ADD, created) |  
//查找ai->volumes.rb\_node  
若找到了则返回；  
如果只是查找，则返回；如果有AV\_ADD参数，则向下走  
没有则分配struct ubi\_ainf\_volume av，指定av->vol\_id成员为  
vol\_id，把av->rb添加到ai->volumes.rb\_node上  
p = &av->root.rb\_node;  
查找av->root.rb\_node（返回aeb）  
若aeb->lnum不等于lnum，即无重复leb，查找下一个节点（continue）  
否则，向下走  
如果已经有一个peb描述此leb了  
如果有两个复制的leb  
//不attach，因为这是unclean reboot  
打印aeb（struct ubi\_ainf\_peb）和vid header  
否则  
//放弃老的peb，保留新的peb  
比较（通过sequence num比较），找到新一些的peb  
add\_to\_list(ai, aeb->pnum, aeb->vol\_id, aeb->lnum,  
aeb->ec, cmp\_res & 4, &ai->erase);  
把找到的peb添加到ai->erase链表上  
//到这里，说明上边查找完了  
检查VID header的有效性  
分配一个struct ubi\_ainf\_peb aeb  
把aeb\->u.rb添加到av->root.rb\_node上

打印：scanning is finished  
late\_analysis(ubi, ai)  
确定flash是否是empty、是否有太多崩溃的（corrupted）PEBs导致不能attach  
对于未知EC的块，将其设为平均值  
//**volume table在布局卷中，也就是前2块。**  
ubi\_read\_volume\_table(ubi, ai) //vtbl.c (drivers/mtd/ubi)  
//**从flash中读volume table**，检查，如果需要：恢复或者创建它  
/\* volume的个数由leb大小和UBI\_MAX\_VOLUMES确定 \*/  
ubi->vtbl\_slots = ubi->leb\_size / UBI\_VTBL\_RECORD\_SIZE;  
if (ubi->vtbl\_slots > UBI\_MAX\_VOLUMES)  
ubi->vtbl\_slots = UBI\_MAX\_VOLUMES;  
ubi->vtbl\_size = ubi->vtbl\_slots \* UBI\_VTBL\_RECORD\_SIZE;  
av = ubi\_find\_av(ai, UBI\_LAYOUT\_VOLUME\_ID);  
//查找布局卷  
find\_or\_add\_av((struct ubi\_attach\_info \*)ai, vol\_id, AV\_FIND, &created);  
//查找ai->volumes.rb\_node  
若找到了则返回；  
如果只是查找，则返回；如果有AV\_ADD参数，则向下走  
没有则分配struct ubi\_ainf\_volume av，指定av->vol\_id成员为  
vol\_id，把av->rb添加到ai->volumes.rb\_node上

如果没有找到  
如果查找的最后一项是空的（ai->is\_empty被置位）  
ubi->vtbl = create\_empty\_lvol(ubi, ai); //vtbl.c(drivers/mtd/ubi)  
//**找2个空的peb，创建两个volume table（冗余），写入flash**  
否则 （**正常走此分支**）  
ubi->vtbl = process\_lvol(ubi, ai, av);  
**读取peb0的data （失败才会读peb1的data）**  
init\_volumes(ubi, ai, ubi->vtbl);  
初始化每个volume在内存上的结构（共有ubi->vtbl\_slots个）  
  
ubi\_wl\_init(ubi, ai); //wl.c (drivers/mtd/ubi)  
//用attaching information初始化wl  
//\#define UBI\_BGT\_NAME\_PATTERN "ubi\_bgt%dd"  
sprintf(ubi->bgt\_name, UBI\_BGT\_NAME\_PATTERN, ubi->ubi\_num);  
//创建peb和leb的映射关系。（用attaching information初始化EBA）  
ubi\_eba\_init(ubi, ai); //eba.c (drivers/mtd/ubi)  
对于每一个volume  
对于RB树每一个节点  
entry = &vol->eba\_tbl->entries\[aeb->lnum\];  
entry->pnum = aeb->pnum;  
  
 **ubi\_devices\[ubi\_num\] = ubi;**  //ubi\_devices数组在 build.c  
uif\_init(ubi, &ref); //build.c (drivers/mtd/ubi)  
//创建设备节点  
cdev\_init(&ubi->cdev, &**ubi\_cdev\_operations**); //此fops在cdev.c (drivers/mtd/ubi)定义  
ubi\_sysfs\_init(ubi, ref);  
ubi->dev.devt = ubi->cdev.dev;  
ubi->dev.class = &ubi\_class;  
ubi->dev.groups = ubi\_dev\_groups;  
dev\_set\_name(&ubi->dev, UBI\_NAME\_STR"%d", ubi->ubi\_num);  
device\_register(&ubi->dev);  
device\_add(dev)  
//创建/dev/ubiN节点  
device\_create\_file(dev, &dev\_attr\_uevent)  
//创建/sys/class/ubi/ubiN/属性文件。//build.c：static struct attribute \*ubi\_dev\_attrs\[\] = ...  
//ATTRIBUTE\_GROUPS(ubi\_dev);  
device\_create\_file(dev, &dev\_attr\_dev);  
对于每一个volume（个数为ubi->vtbl\_slots）  
如果已经制作了卷了（ubi->volumes\[i\]非NULL）  
（**调用过ubimkvol命令之后才会给ubi->volumes\[i\]赋值**）  
ubi\_add\_volume(ubi, ubi->volumes\[i\]) //vmt.c (drivers/mtd/ubi)  
ubi\_debugfs\_init\_dev(ubi); //debug.c (drivers/mtd/ubi)  
ubi->bgt\_thread = kthread\_create(ubi\_thread, ubi, "%s", ubi->bgt\_name); //ubi\_thread在 wl.c  
//创建名为ubi\_bgt%dd的线程，用于磨损均衡  
打印信息：attached mtd%d (name \\"%s\\", size %llu MiB)  
...（都是打印信息）  
最后打印：available PEBs: %d, total reserved PEBs: %d, PEBs reserved for bad PEB handling: %d  
ubi\_notify\_all(ubi, UBI\_VOLUME\_ADDED, NULL);  
//向所有volume发送通知  
对于每一个volume（共ubi->vtbl\_slots个）  
如果ubi->volumes\[i\]为NULL  
continue  
否则  
向下走  
//kapi.c : BLOCKING\_NOTIFIER\_HEAD(ubi\_notifiers)  
blocking\_notifier\_call\_chain(&ubi\_notifiers, ntype, &nt);  
调用ubi\_notifiers上的每一个成员的add函数  
//drivers/mtd/ubi/build.c=>ubi\_init=>ubiblock\_init =>  
ubi\_register\_volume\_notifier(&ubiblock\_notifier, 1);  
//把成员放到了ubi\_notifiers上 （blocking\_notifier\_chain\_register(&ubi\_notifiers, nb);)

# ubimkvol #

## ubimkvol应用层 ##

ubimkvol.c=> main  
parse\_opt(argc, argv)  
libubi\_open()  
组合/sys/class/相关路径  
lib->sysfs\_ctrl = /sys/class/misc/ubi\_ctrl/  
lib->ctrl\_dev = /sys/class/misc/ubi\_ctrl/dev  
lib->sysfs\_ubi = /sys/class/ubi  
lib->ubi\_dev = /sys/class/ubi/ubiN  
lib->ubi\_version = /sys/class/ubi/version  
lib->dev\_dev = /sys/class/ubi/ubiN/dev  
lib->dev\_avail\_ebs = /sys/class/ubi/ubiN/avail\_eraseblocks  
下边简写，都是lib->xxx = /sys/class/ubi/ubiN/xxx  
dev\_total\_ebs = total\_eraseblocks  
...  
max\_vol\_count =  
dev\_mtd\_num  
ubi\_vol  
vol\_type  
vol\_dev  
vol\_alignment  
...  
//确定节点信息是否正确（是否是字符节点等）  
ubi\_probe\_node(libubi, args.node);  
ubi\_get\_dev\_info(libubi, args.node, &dev\_info)  
打印"Set volume size to %lld\\n"  
ubi\_mkvol(libubi, args.node, &req)  
fd = open(node, O\_RDONLY); //node为/dev/ubiN  
ioctl(fd, UBI\_IOCMKVOL, &r);

## ubimkvol底层 ##

ioctl(fd, UBI\_IOCMKVOL, &r);  
ubi\_cdev\_ioctl //drivers/mtd/ubi/cdev.c => ubi\_cdev\_operations => .unlocked\_ioctl = ubi\_cdev\_ioctl  
struct ubi\_device \*ubi;  
struct ubi\_mkvol\_req req;  
ubi = ubi\_get\_by\_major(imajor(file->f\_mapping->host));  
对于ubimkvol，走下边（UBI\_IOCMKVOL）  
copy\_from\_user(&req, argp, sizeof(struct ubi\_mkvol\_req))  
//检测参数合法性  
verify\_mkvol\_req(ubi, &req);  
ubi\_create\_volume(ubi, &req); //vmt.c  
struct ubi\_volume \*vol;  
struct ubi\_eba\_table \*eba\_tbl = NULL;  
struct ubi\_vtbl\_record vtbl\_rec;  
  
**vol = kzalloc(sizeof(struct ubi\_volume), GFP\_KERNEL);**  
vol->usable\_leb\_size = ubi->leb\_size - ubi->leb\_size % req->alignment;  
vol->reserved\_pebs = div\_u64(req->bytes + vol->usable\_leb\_size - 1, vol->usable\_leb\_size);  
//执行（结束）所有挂起的任务  
ubi\_wl\_flush(ubi, vol\_id, UBI\_ALL)  
eba\_tbl = ubi\_eba\_create\_table(vol, vol->reserved\_pebs); //eba.c (drivers/mtd/ubi)  
struct ubi\_eba\_table \*tbl;  
分配vol->reserved\_pebs个int（4字节）空间（这是pnum），首地址给tbl->entries  
把每个tbl->entries的pnum成员设为UBI\_LEB\_UNMAPPED （即-1）  
ubi\_eba\_replace\_table(vol, eba\_tbl); //eba.c (drivers/mtd/ubi)  
释放vol->eba\_tbl  
将vol->eba\_tbl指向上边刚创建的eba\_tbl  
  
cdev\_init(&vol->cdev, &**ubi\_vol\_cdev\_operations**);  
//cdev.c：struct file\_operations ubi\_vol\_cdev\_operations = ...  
dev = MKDEV(MAJOR(ubi->cdev.dev), vol\_id + 1);  
cdev\_add(&vol->cdev, dev, 1);  
vol->dev.parent = &ubi->dev;  
vol->dev.devt = dev;  
vol->dev.class = &ubi\_class;  
vol->dev.groups = volume\_dev\_groups;  
dev\_set\_name(&vol->dev, "%s\_%d", ubi->ubi\_name, vol->vol\_id);  
device\_register(&vol->dev)  
  
//填充vtbl\_rec  
memset(&vtbl\_rec, 0, sizeof(struct ubi\_vtbl\_record));  
vtbl\_rec.reserved\_pebs = cpu\_to\_be32(vol->reserved\_pebs);  
vtbl\_rec.alignment = cpu\_to\_be32(vol->alignment);  
vtbl\_rec.data\_pad = cpu\_to\_be32(vol->data\_pad);  
vtbl\_rec.name\_len = cpu\_to\_be16(vol->name\_len);  
  
ubi\_change\_vtbl\_record(ubi, vol\_id, &vtbl\_rec); //vtbl.c (drivers/mtd/ubi)  
memcpy(&ubi->vtbl\[idx\], vtbl\_rec, sizeof(struct ubi\_vtbl\_record));  
**//更新flash上的layout volume （第0、1块）**  
ubi\_update\_layout\_vol(ubi); //vtbl.c (drivers/mtd/ubi)  
for (i = 0; i < UBI\_LAYOUT\_VOLUME\_EBS; i++) \{ // UBI\_LAYOUT\_VOLUME\_EBS = 2  
ubi\_eba\_atomic\_leb\_change(ubi, layout\_vol, i, ubi->vtbl, ubi->vtbl\_size); //eba.c  
  
ubi\_volume\_notify(ubi, vol, UBI\_VOLUME\_ADDED); //build.c (drivers/mtd/ubi)  
blocking\_notifier\_call\_chain(&ubi\_notifiers, ntype, &nt);  
//kapi.c : BLOCKING\_NOTIFIER\_HEAD(ubi\_notifiers)  
调用ubi\_notifiers上的每一个成员的add函数  
//drivers/mtd/ubi/build.c=>ubi\_init=>ubiblock\_init =>  
ubi\_register\_volume\_notifier(&ubiblock\_notifier, 1);  
//此函数里把成员放到了ubi\_notifiers上 （blocking\_notifier\_chain\_register(&ubi\_notifiers, nb);)

# mount #

## mount底层 ##

SYSCALL\_DEFINE5 //namespace.c (kernel/fs)  
/\* 获取mount类型 \*/  
kernel\_type = copy\_mount\_string(type);  
/\* 获取设备名称字符串 \*/  
kernel\_dev = copy\_mount\_string(dev\_name);  
/\* 获取其它选项 \*/  
options = copy\_mount\_options(data);  
do\_mount(kernel\_dev, dir\_name, kernel\_type, flags, options); //namespace.c (kernel/fs)  
/\* 通过mount目录字符串获取path，path结构中包含有mount目录的dentry目录对象 \*/  
retval = user\_path(dir\_name, &path);  
do\_new\_mount(&path, type\_page, flags, mnt\_flags, dev\_name, data\_page); //namespace.c (kernel/fs)  
type = get\_fs\_type(fstype);  
vfs\_kern\_mount(type, flags, name, data); //namespace.c (kernel/fs)  
mount\_fs(type, flags, name, data); //super.c (kernel/fs)  
struct dentry \*root;  
root = type->mount(type, flags, name, data);  
/\* kernel/fs/ubifs/super.c: register\_filesystem(&ubifs\_fs\_type);  
\* ubifs\_fs\_type.mount = ubifs\_mount  
\*/  
ubifs\_mount(type, flags, name, data); //super.c (kernel/fs/ubifs/)

ubifs\_mount(type, flags, name, data); //super.c (kernel/fs/ubifs/)  
struct ubifs\_info \*c;  
struct super\_block \*sb;

open\_ubi(name, UBI\_READONLY); //super.c (kernel/fs/ubifs/)  
ubi\_open\_volume(dev, vol, mode); //kapi.c (kernel/mtd/ubi)  
struct ubi\_volume\_desc \*desc;  
struct ubi\_volume \*vol;  
struct ubi\_device \*ubi;

ubi = ubi\_get\_device(ubi\_num); //build.c (drivers/mtd/ubi)  
desc = kmalloc(sizeof(struct ubi\_volume\_desc), GFP\_KERNEL);  
vol = ubi->volumes\[vol\_id\];  
vol->ref\_count += 1;  
desc->vol = vol;  
c = alloc\_ubifs\_info(ubi); //super.c (kernel/fs/ubifs/)  
// 查找或者创建一个super block  
sb = sget(fs\_type, sb\_test, sb\_set, flags, c); //super.c (kernel/fs)  
  
ubifs\_fill\_super(sb, data, flags & MS\_SILENT ? 1 : 0); //super.c (kernel/fs/ubifs/)  
struct ubifs\_info \*c = sb->s\_fs\_info;  
  
c->ubi = ubi\_open\_volume(c->vi.ubi\_num, c->vi.vol\_id, UBI\_READWRITE);  
bdi\_init(&c->bdi);  
bdi\_register(&c->bdi, NULL, "ubifs\_%d\_%d", c->vi.ubi\_num, c->vi.vol\_id);  
ubifs\_parse\_options(c, data, 0);  
mount\_ubifs(c); //super.c (kernel/fs/ubifs)  
check\_volume\_empty(c)  
ubifs\_read\_superblock(c); //sb.c (kernel/fs/ubifs)  
struct ubifs\_sb\_node \*sup;  
如果c->empty //第一次使用走此分支  
create\_default\_filesystem(c); //sb.c (kernel/fs/ubifs)  
//设置journal、log、最大bud、orphan、main的leb数目  
设置jnl\_lebs  
通过jnl\_lebs设置log\_lebs,log\_lebs自加1（预留1个leb给commit使用）  
设置max\_buds：max\_buds = jnl\_lebs - log\_lebs;  
设置orph\_lebs：orph\_lebs = UBIFS\_MIN\_ORPH\_LEBS;  
设置main\_lebs：  
main\_lebs = c->leb\_cnt - UBIFS\_SB\_LEBS - UBIFS\_MST\_LEBS - log\_lebs;  
main\_lebs -= orph\_lebs;  
设置lpt的首leb：lpt\_first = UBIFS\_LOG\_LNUM + log\_lebs;  
  
//创建default lpt  
ubifs\_create\_dflt\_lpt(c, &main\_lebs, lpt\_first, &lpt\_lebs, &big\_lpt);  
//计算default lpt的各个大小（c->lpt\_lebs、c->main\_lebs等）  
calc\_dflt\_lpt\_geom(c, main\_lebs, big\_lpt);  
**把lpt写到flash中（一般是2页）**  
dbg\_gen("LEB Properties Tree created (LEBs %d-%d)",lpt\_first, lpt\_first + lpt\_lebs - 1);  
  
设置super block node的值  
//**把super block写到flash中（leb 0:0）**  
ubifs\_write\_node(c, sup, UBIFS\_SB\_NODE\_SZ, 0, 0); //io.c (kernel/fs/ubifs)  
  
设置master node的值  
//**把master写到flash中（leb 1:0和leb 2:0）**  
ubifs\_write\_node(c, mst, UBIFS\_MST\_NODE\_SZ, UBIFS\_MST\_LNUM, 0);  
ubifs\_write\_node(c, mst, UBIFS\_MST\_NODE\_SZ, UBIFS\_MST\_LNUM + 1, 0);  
//\#define UBIFS\_MST\_LNUM (UBIFS\_SB\_LNUM + UBIFS\_SB\_LEBS)  
dbg\_gen("default master node created at LEB %d:0", UBIFS\_MST\_LNUM);  
  
创建root indexing node  
//**把root indexing node写到flash**  
ubifs\_write\_node(c, idx, tmp, main\_first + DEFAULT\_IDX\_LEB, 0);  
//DEFAULT\_IDX\_LEB = 0  
dbg\_gen("default root indexing node created LEB %d:0",  
main\_first + DEFAULT\_IDX\_LEB);  
  
创建default root inode  
//**把default root inode写到flash**  
ubifs\_write\_node(c, ino, UBIFS\_INO\_NODE\_SZ, main\_first + DEFAULT\_DATA\_LEB, 0);  
//DEFAULT\_DATA\_LEB = 1  
  
创建commit start node (log中的第0个node)  
//**把commit start node写到flash**  
ubifs\_write\_node(c, cs, UBIFS\_CS\_NODE\_SZ, UBIFS\_LOG\_LNUM, 0);  
//\#define UBIFS\_LOG\_LNUM (UBIFS\_MST\_LNUM + UBIFS\_MST\_LEBS)  
  
打印："default file-system created"  
//**从flash中读出super block node**  
sup = ubifs\_read\_sb\_node(c); //sb.c (kernel/fs/ubifs)  
//初始化super block的常量、检查参数信息  
init\_constants\_sb(c);  
alloc\_wbufs(c);  
//如果不是只读挂载，则创建背景线程  
c->bgt = kthread\_create(ubifs\_bg\_thread, c, "%s", c->bgt\_name); //commit.c (kernel/fs/ubifs)  
ubifs\_bg\_thread  
1. 一个write-buffer时钟到期时，同步相应的write-buffer  
2. journal要满时，提前commit  
  
//从flash中读出master node  
ubifs\_read\_master(c); //master.c (kernel/fs/ubifs)  
err = scan\_for\_master(c);  
如果返回值是-EUCLEAN （unclean reboot）  
ubifs\_recover\_master\_node(c);  
//初始化master的常量、检查参数信息  
init\_constants\_master(c);  
  
//初始化用来读写的lpt  
ubifs\_lpt\_init(c, 1, !c->ro\_mount); //lpt.c (kernel/fs/ubifs)  
ubifs\_replay\_journal(c); //replay.c (kernel/fs/ubifs)  
扫描journal，重现、清除。  
//保证所有uncommited journal相关的内存结构体被建立(dirty TNC tree, tree of buds,  
// modified lprops, etc)  
ubifs\_mount\_orphans(c, c->need\_recovery, c->ro\_mount); //orphan.c  
c->orph\_buf = vmalloc(c->leb\_size);  
如果上次umount不干净，删除记录为orphans的节点  
打印："UBIFS: mounted UBI device %d, volume %d, name \\"%s\\"%s"  
"LEB size: %d bytes (%d KiB), min./max. I/O unit sizes: %d bytes/%d bytes"  
"FS size: %lld bytes (%lld MiB, %d LEBs), journal size %lld bytes (%lld MiB, %d LEBs)"  
"reserved for root: %llu bytes (%llu KiB)"  
"media format: w%d/r%d (latest is w%d/r%d), UUID %pUB%s"  
dbg\_gen：  
"default compressor: %s"  
"data journal heads: %d""log LEBs: %d (%d - %d)"  
...  
"commit number: %llu"

[ubi_IT_-CSDN]: https://knife.blog.csdn.net/article/details/95477594
[mtd-utils]: http://www.linux-mtd.infradead.org/index.html
[mtd-utils 1]: http://ftp//ftp.infradead.org/pub/mtd-utils/
[mtd-utils 2]: http://git.infradead.org/
[mtd]: https://blog.csdn.net/feiying0canglang/article/details/95209148#%E8%AF%BB
[mtd 1]: https://blog.csdn.net/feiying0canglang/article/details/95209148#%E5%86%99