文件数据读取【续二】

港控/mmm° 2022-01-17 05:15 214阅读 0赞

【read--->vfs\_read--->do\_sync\_read--->aio\_read--->do\_generic\_file\_read--->readpage--->mpage\_readpage--->mpage\_bio\_submit】

static struct bio \*mpage\_bio\_submit(int rw, struct bio \*bio)

bio->bi\_end\_io = mpage\_end\_io;

submit\_bio(rw, bio);

return NULL;

【read--->vfs\_read--->do\_sync\_read--->aio\_read--->do\_generic\_file\_read--->readpage--->mpage\_readpage--->mpage\_bio\_submit--->submit\_bio】

void submit\_bio(int rw, struct bio \*bio)

int count = bio\_sectors(bio);

bio->bi\_rw |= rw;

......

generic\_make\_request(bio);

通过函数generic\_make\_request将bio添加到一个请求。

【read--->vfs\_read--->do\_sync\_read--->aio\_read--->do\_generic\_file\_read--->readpage--->mpage\_readpage--->mpage\_bio\_submit--->submit\_bio--->generic\_make\_request】

void generic\_make\_request(struct bio \*bio)

struct bio\_list bio\_list\_on\_stack;

if (!generic\_make\_request\_checks(bio))

return;

if (current->bio\_list) \{

bio\_list\_add(current->bio\_list, bio);

return;

BUG\_ON(bio->bi\_next);

bio\_list\_init(&bio\_list\_on\_stack);

current->bio\_list = &bio\_list\_on\_stack;

do \{

struct request\_queue \*q = bdev\_get\_queue(bio->bi\_bdev);

q->make\_request\_fn(q, bio);

bio = bio\_list\_pop(current->bio\_list);

\} while (bio);

current->bio\_list = NULL; /\* deactivate \*/

获取bio对应的块设备文件对应的磁盘对象的请求队列，然后调用函数q->make\_request\_fn创建一个请求用bio初始化并添加到请求队列中。

【blk\_init\_queue】

每一个数据请求都挂在请求队列上并接受请求队列中请求处理函数request\_fn的处理。所以这里先分析请求队列的创建与初始化。

struct request\_queue \*blk\_init\_queue(request\_fn\_proc \*rfn, spinlock\_t \*lock)

return blk\_init\_queue\_node(rfn, lock, -1);

【blk\_init\_queue--->blk\_init\_queue\_node】

struct request\_queue \*blk\_init\_queue\_node(request\_fn\_proc \*rfn, spinlock\_t \*lock, int node\_id)

struct request\_queue \*uninit\_q, \*q;

uninit\_q = blk\_alloc\_queue\_node(GFP\_KERNEL, node\_id);

if (!uninit\_q)

return NULL;

q = blk\_init\_allocated\_queue(uninit\_q, rfn, lock);

if (!q)

blk\_cleanup\_queue(uninit\_q);

return q;

首先通过函数blk\_alloc\_queue\_node分配一个请求队列结构 request\_queue。然后通过函数blk\_init\_allocated\_queue初始化已分配的请求队列。函数指针rfn是请求处理函数，最终将让请求队列的request\_fn字段指向该函数。

【blk\_init\_queue--->blk\_init\_queue\_node--->blk\_init\_allocated\_queue】

struct request\_queue \*blk\_init\_allocated\_queue(struct request\_queue \*q, request\_fn\_proc \*rfn, spinlock\_t \*lock)

.......

q->request\_fn= rfn;

......

blk\_queue\_make\_request(q, blk\_queue\_bio);

......

return NULL;

首先让请求队列的request\_fn字段指向实际请求处理函数。然后在函数blk\_queue\_make\_request中让请求队列的make\_request\_fn字段指向实际请求创建函数blk\_queue\_bio。

【read--->vfs\_read--->do\_sync\_read--->aio\_read--->do\_generic\_file\_read--->readpage--->mpage\_readpage--->mpage\_bio\_submit--->submit\_bio--->generic\_make\_request--->make\_request\_fn】

void blk\_queue\_bio(struct request\_queue \*q, struct bio \*bio)

const bool sync = !!(bio->bi\_rw & REQ\_SYNC);

struct blk\_plug \*plug;

int el\_ret, rw\_flags, where = ELEVATOR\_INSERT\_SORT;

struct request \*req;

unsigned int request\_count = 0;

blk\_queue\_bounce(q, &bio);

if (bio->bi\_rw & (REQ\_FLUSH | REQ\_FUA)) \{

spin\_lock\_irq(q->queue\_lock);

where = ELEVATOR\_INSERT\_FLUSH;

goto get\_rq;

if (attempt\_plug\_merge(q, bio, &request\_count))

return;

spin\_lock\_irq(q->queue\_lock);

el\_ret = elv\_merge(q, &req, bio);

if (el\_ret == ELEVATOR\_BACK\_MERGE) \{

if (bio\_attempt\_back\_merge(q, req, bio)) \{

if (!attempt\_back\_merge(q, req))

elv\_merged\_request(q, req, el\_ret);

goto out\_unlock;

\} else if (el\_ret == ELEVATOR\_FRONT\_MERGE) \{

if (bio\_attempt\_front\_merge(q, req, bio)) \{

if (!attempt\_front\_merge(q, req))

elv\_merged\_request(q, req, el\_ret);

goto out\_unlock;

函数elv\_merge试图在请求队列中找到一个能够合并该bio的request，该函数返回三个可能值：ELEVATOR\_NO\_MERGE，队列已经存在的请求中不包含bio结构，需要创建一个新的请求。ELEVATOR\_BACK\_MERGE，bio结构作为末尾的bio而插入到某个请求中。ELEVATOR\_FRONT\_MERGE，bio结构可作为某个请求的第一个bio被插入。

get\_rq:

rw\_flags = bio\_data\_dir(bio);

if (sync)

rw\_flags |= REQ\_SYNC;

req = get\_request\_wait(q, rw\_flags, bio);

if (unlikely(!req)) \{

bio\_endio(bio, -ENODEV);/\* @q is dead \*/

goto out\_unlock;

init\_request\_from\_bio(req, bio);

if (test\_bit(QUEUE\_FLAG\_SAME\_COMP, &q->queue\_flags))

req->cpu = raw\_smp\_processor\_id();

plug = current->plug;

if (plug) \{

if (list\_empty(&plug->list))

trace\_block\_plug(q);

else \{

if (!plug->should\_sort) \{

struct request \*\_\_rq;

\_\_rq = list\_entry\_rq(plug->list.prev);

if (\_\_rq->q != q)

plug->should\_sort = 1;

if (request\_count >= BLK\_MAX\_REQUEST\_COUNT) \{

blk\_flush\_plug\_list(plug, false);

trace\_block\_plug(q);

list\_add\_tail(&req->queuelist, &plug->list);

drive\_stat\_acct(req, 1);

\} else \{

spin\_lock\_irq(q->queue\_lock);

add\_acct\_request(q, req, where);

\_\_blk\_run\_queue(q);

out\_unlock:

spin\_unlock\_irq(q->queue\_lock);

当函数elv\_merge返回ELEVATOR\_NO\_MERGE即需要创建一个新的请求时，先调用函数get\_request\_wait分配一个请求，然后通过函数init\_request\_from\_bio将bio添加到该请求。如果设置了plug则请求队列被阻塞，当多个请求产生时，请求才得以处理，以此获得最佳性能。如果没有设置plug则调用函数\_\_blk\_run\_queue立即对请求进行处理。该函数将调用请求处理函数q->request\_fn(q);。

转载于:https://blog.51cto.com/csdyabc/866220