linux 块设备子系统,Linux块设备IO子系统(二) _页高速缓存

￡神魔★判官ぃ 2023-01-21 05:28 176阅读 0赞

磁盘驱动就是实现磁盘空间和内存空间数据上的交互，在上一篇中我们讨论了内存端的Page Segment Block Sector相关的概念，本文以3.14内核为例，讨论这部分内存是如何被组织管理的。我们知道，为了解决CPU和内存的速度不匹配，计算机系统引入了Cache缓存机制，这种硬件Cache的速度接近CPU内部寄存器的速度，可以提高系统效率，同样的思路也适用于解决内存和磁盘的速度不匹配问题，此外，磁盘多是机械式的，从寿命的角度考虑也不适合频繁读写，所以内核就将一部分内存作为缓存，提高磁盘访问速度的同时延长磁盘寿命，这种缓存就是磁盘高速缓存。包括页高速缓存(Page Cache，对完整数据页进行操作的磁盘高速缓存) + 目录项高速缓存(Dentry Cache，描述文件系统路径名的目录项对象) + 索引节点高速缓存(Buffer Cache，存放的是描述磁盘索引节点的索引节点对象)，本文主要讨论页高速缓存，有了页高速缓存，内核的代码和数据结构不必从磁盘读，也不必写入磁盘。页高速缓存可以看作特定文件系统层的一部分。

SYSCALL\_DEFINE3(read, unsigned int, fd, char \_\_user \*, buf, size\_t, count)

└── vfs\_read(f.file, buf, count, &pos);

└──file->f\_op->read(file, buf, count, pos);

└──do\_sync\_read(file, buf, count, pos);

└──filp->f\_op->aio\_read(&kiocb, &iov, 1, kiocb.ki\_pos);

├──generic\_file\_aio\_read(struct kiocb \*iocb, const struct iovec \*iov, unsigned long nr\_segs, loff\_t pos)

└──filemap\_write\_and\_wait\_range(mapping, pos, pos + iov\_length(iov, nr\_segs) - 1);

\-----------------------------------Page Cache----------------------------------------------------

int mpage\_readpage(struct page \*page, get\_block\_t get\_block)

└──wait\_on\_sync\_kiocb(&kiocb);

├──do\_mpage\_readpage(bio, page, 1, &last\_block\_in\_bio, &map\_bh, &first\_logical\_block, get\_block);

└──mpage\_bio\_submit(READ, bio);

└──submit\_bio(rw, bio);

![da759dea0dc32024e70e02316c942148.png][]

绝大多数情况下，内核在读写磁盘时都引用页高速缓存。新页被追加到页高速缓存以满足用户态进程的读请求。如果页不再高速缓存中，新页就被加到高速缓存中，然后用从磁盘读出的数据填充它，如果内存有足够的空闲空间，就让该页在高速缓存中长期保留，使其他进程再使用该页时不再访问磁盘。

同样，在把一页数据写到块设备之前，内核首先检查对应的页是否已经在高速缓存中，如果不在，就要先在其中增加一个新项，并用要写到磁盘中的数据填充该项。IO数据的传送不是马上开始，而是延迟几秒才对磁盘进行更新，从而使进程有机会队要写入磁盘的数据做进一步的修改。

页高速缓存肯可能是下面几种之一：

含有普通文件数据的页(上篇中的一个Page)

含有目录的页

含有直接从块设备文件(跳过文件系统)读出的数据的页。

含有用户态进程数据的页

属于特殊文件系统文件的页，如shm

从inode到page

既然是建立一块磁盘空间和一块内存空间之间的关系，那么就要通过相关的结构表示这种关系，在磁盘端，存储空间本质上都是属于一个文件，Linux中用inode结构表示一个文件，内存端，Linux内核用address\_space来组织一组内存页，所以，我们可以在inode结构中找到相应的address\_space对象域，而这个文件就成为该页的所有者(owner)。简单的追一下代码，我们可以画出下面这张关系图，本节主要围绕这张图讨论

inode

inode是内核中描述一个文件的结构，更多关于inode的讨论，可以参考Linux设备文件三大结构：inode,file,file\_operations，本文中我们主要关心i\_mapping和i\_data两个成员。

//3.14/include/linux/fs.h

527 struct inode \{

541 struct address\_space \*i\_mapping;

594 struct address\_space i\_data;

616 \};

struct inode

\--541-->指向这个inode拥有的address\_space对象

\--594-->这个inode拥有的address\_space对象

address\_space

页高速缓存的核心结构就address\_space对象，他是一个嵌入在页所有者的索引节点对象中的数据结构。高速缓存中的许多页都可能属于一个所有者，从而可能被链接到同一个address\_space对象。该对象还在所有者的页和对这些页的操作之间建立起链接关系。

412 struct address\_space \{

413 struct inode \*host; /\* owner: inode, block\_device \*/

414 struct radix\_tree\_root page\_tree; /\* radix tree of all pages \*/

415 spinlock\_t tree\_lock; /\* and lock protecting it \*/

416 unsigned int i\_mmap\_writable;/\* count VM\_SHARED mappings \*/

417 struct rb\_root i\_mmap; /\* tree of private and shared mappings \*/

418 struct list\_head i\_mmap\_nonlinear;/\*list VM\_NONLINEAR mappings \*/

419 struct mutex i\_mmap\_mutex; /\* protect tree, count, list \*/

420 /\* Protected by tree\_lock together with the radix tree \*/

421 unsigned long nrpages; /\* number of total pages \*/

422 pgoff\_t writeback\_index;/\* writeback starts here \*/

423 const struct address\_space\_operations \*a\_ops; /\* methods \*/

424 unsigned long flags; /\* error bits/gfp mask \*/

425 struct backing\_dev\_info \*backing\_dev\_info; /\* device readahead, etc \*/

426 spinlock\_t private\_lock; /\* for use by the address\_space \*/

427 struct list\_head private\_list; /\* ditto \*/

428 void \*private\_data; /\* ditto \*/

429 \} \_\_attribute\_\_((aligned(sizeof(long))));

struct address\_space

\--413-->这个address\_space对象所属的inode对象

\--414-->这个address\_space对象拥有的radix\_tree\_root对象

\--425-->指向backing\_dev\_info对象，这个对象描述了所有者的数据所在的块设备，通常嵌入在块设备的请求队列描述符中。

radix\_tree\_root

描述一个radix树的根，内核使用这个数据结构快速的查找增删一个inode拥有的页高速缓存页

64 struct radix\_tree\_root \{

65 unsigned int height;

66 gfp\_t gfp\_mask;

67 struct radix\_tree\_node \_\_rcu \*rnode;

68 \};

50 struct radix\_tree\_node \{

51 unsigned int height; /\* Height from the bottom \*/

52 unsigned int count;

53 union \{

54 struct radix\_tree\_node \*parent; /\* Used when ascending tree \*/

55 struct rcu\_head rcu\_head; /\* Used when freeing node \*/

56 \};

57 void \_\_rcu \*slots\[RADIX\_TREE\_MAP\_SIZE\];

58 unsigned long tags\[RADIX\_TREE\_MAX\_TAGS\]\[RADIX\_TREE\_TAG\_LONGS\];

59 \};

struct radix\_tree\_node

\--51-->当前树的深度，不包括叶子节点的层数

\--52-->记录节点中非空指针数量的计数器

\--57-->slot是包含64个指针的数组，每个元素可以指向其他节点(struct radix\_tree\_node)或者页描述符(struct page)，上层节点指向其他节点，底层节点指向页描述符(叶子节点)

\--58-->tag二维数组用于对radix\_tree\_node基树进行标记，下面就是一个页可能的标志

74 enum pageflags\{

75 PG\_locked, /\* Page is locked. Don't touch. \*/

76 PG\_error,

77 PG\_referenced,

78 PG\_uptodate,

79 PG\_dirty,

80 PG\_lru,

81 PG\_active,

82 PG\_slab,

83 PG\_owner\_priv\_1, /\* Owner use. If pagecache, fs may use\*/

84 PG\_arch\_1,

85 PG\_reserved,

86 PG\_private, /\* If pagecache, has fs-private data \*/

87 PG\_private\_2, /\* If pagecache, has fs aux data \*/

88 PG\_writeback, /\* Page is under writeback \*/

93 PG\_compound, /\* A compound page \*/

95 PG\_swapcache, /\* Swap page: swp\_entry\_t in private \*/

96 PG\_mappedtodisk, /\* Has blocks allocated on-disk \*/

97 PG\_reclaim, /\* To be reclaimed asap \*/

98 PG\_swapbacked, /\* Page is backed by RAM/swap \*/

99 PG\_unevictable, /\* Page is "unevictable" \*/

112 \_\_NR\_PAGEFLAGS,

113

114 /\* Filesystems \*/

115 PG\_checked = PG\_owner\_priv\_1,

116

117 /\* Two page bits are conscripted by FS-Cache to maintain local caching

118 \* state. These bits are set on pages belonging to the netfs's inodes

119 \* when those inodes are being locally cached.

120 \*/

121 PG\_fscache = PG\_private\_2, /\* page backed by cache \*/

122

123 /\* XEN \*/

124 PG\_pinned = PG\_owner\_priv\_1,

125 PG\_savepinned = PG\_dirty,

126

127 /\* SLOB \*/

128 PG\_slob\_free = PG\_private,

129 \};

page

page就是内核中页描述符，通过radix树的操作，我们最终可以找到一组page，这组page归属于一个inode。我们可以看到其中的pgoff\_t index成员，用来表示当前页在整组高速缓存页中的索引。至此，我们就通过一个文件的inode找到了它拥有的页高速缓存，接接下来就是使用块设备驱动实现相应的页缓存和磁盘的数据交互。

44 struct page \{

48 union \{

49 struct address\_space \*mapping; /\* If low bit clear, points to

57 \};

59 /\* Second double word \*/

60 struct \{

61 union \{

62 pgoff\_t index; /\* Our offset within mapping. \*/

73 \};

121 \};

198 \}

页高速缓存的基本操作是增删查更，在此基础上可以封装更高级的API

增加page

static inline int add\_to\_page\_cache(struct page \*page, struct address\_space \*mapping, pgoff\_t offset, gfp\_t gfp\_mask)

删除page

void delete\_from\_page\_cache(struct page \*page)

查找page

struct page \*find\_get\_page(struct address\_space \*mapping, pgoff\_t offset)

unsigned find\_get\_pages(struct address\_space \*mapping, pgoff\_t start,unsigned int nr\_pages, struct page \*\*pages)

//抢不到锁会阻塞

struct page \*find\_lock\_page(struct address\_space \*mapping, pgoff\_t offset)

//抢不到锁立即返回try???

//抢不到锁会阻塞，但是如果页不存在就创建新的

struct page \*find\_or\_create\_page(struct address\_space \*mapping,pgoff\_t index, gfp\_t gfp\_mask)

更新page

truct page \*read\_cache\_page(struct address\_space \*mapping,pgoff\_t index,int (\*filler)(void \*, struct page \*),void \*data)

从page 到 block

block即是那个VFS或文件系统中的最小逻辑操作单位，一个页高速缓存可以由几个block构成，他们之间的关系如下：

![5a08d1a39798165f72f93ae71a521dd2.png][]

buffer\_head

每个块缓冲区都有相应的buffer\_head对象描述，该描述符包含内核必须了解的，有关如何处理块的所有信息，

62 struct buffer\_head \{

63 unsigned long b\_state; /\* buffer state bitmap (see above) \*/

64 struct buffer\_head \*b\_this\_page;/\* circular list of page's buffers \*/

65 struct page \*b\_page; /\* the page this bh is mapped to \*/

67 sector\_t b\_blocknr; /\* start block number \*/

68 size\_t b\_size; /\* size of mapping \*/

69 char \*b\_data; /\* pointer to data within the page \*/

71 struct block\_device \*b\_bdev;

72 bh\_end\_io\_t \*b\_end\_io; /\* I/O completion \*/

73 void \*b\_private; /\* reserved for b\_end\_io \*/

74 struct list\_head b\_assoc\_buffers; /\* associated with another mapping \*/

75 struct address\_space \*b\_assoc\_map; /\* mapping this buffer is

76 associated with \*/

77 atomic\_t b\_count; /\* users using this buffer\_head \*/

78 \};

struct buffer\_head

\--63-->缓冲区状态标志

\--64-->指向缓冲区的链表中的下一个元素的指针

\--65-->指向拥有该块的缓冲区页的描述符的指针

\--67-->块引用计数

\--68-->块大小

\--69-->表示块缓冲区在缓冲区页中的位置，实际上，这个位置的编号依赖于页是否在高端内存，如果在高端内存，则b\_data字段存放的是块缓冲区相对于页的起始位置的偏移量，否则，b\_data存放的是块缓冲区的线性地址

\--71-->指向IO完成方法数据的指针

\--72-->IO完成方法

\--73-->指向IO完成方法数据的指针

\--74-->为与某个索引节点相关的间接块的链表提供的指针

下面是b\_state可能的取值

//include/linux/buffer\_head.h

19 enum bh\_state\_bits\{

20 BH\_Uptodate, /\* Contains valid data \*/

21 BH\_Dirty, /\* Is dirty \*/

22 BH\_Lock, /\* Is locked \*/

23 BH\_Req, /\* Has been submitted for I/O \*/

24 BH\_Uptodate\_Lock,/\* Used by the first bh in a page, to serialise

25 \* IO completion of other buffers in the page

26 \*/

28 BH\_Mapped, /\* Has a disk mapping \*/

29 BH\_New, /\* Disk mapping was newly created by get\_block \*/

30 BH\_Async\_Read, /\* Is under end\_buffer\_async\_read I/O \*/

31 BH\_Async\_Write, /\* Is under end\_buffer\_async\_write I/O \*/

32 BH\_Delay, /\* Buffer is not yet allocated on disk \*/

33 BH\_Boundary, /\* Block is followed by a discontiguity \*/

34 BH\_Write\_EIO, /\* I/O error on write \*/

35 BH\_Unwritten, /\* Buffer is allocated on disk but not written \*/

36 BH\_Quiet, /\* Buffer Error Prinks to be quiet \*/

37 BH\_Meta, /\* Buffer contains metadata \*/

38 BH\_Prio, /\* Buffer should be submitted with REQ\_PRIO \*/

39 BH\_Defer\_Completion, /\* Defer AIO completion to workqueue \*/

41 BH\_PrivateStart,/\* not a state bit, but the first bit available

42 \* for private allocation by other entities

43 \*/

44 \};

增

将块设备缓冲区所在的页添加到页高速缓存中

static int grow\_buffers(struct block\_device \*bdev, sector\_t block, int size)

删

将块设备缓冲区所在的页从页高速缓存中剔除

int try\_to\_free\_buffers(struct page \*page)

int try\_to\_release\_page(struct page \*page, gfp\_t gfp\_mask)

查

在页高速缓存中搜索块

当内核需要读写一个单独的物理设备块时(例如一个超级块)，必须检查所有请求的块，缓冲区是否已经在页高速缓存中。在页高速缓存中搜索执行的块缓冲区(由块设备描述符的地址bdev和逻辑块号nr表示)的过程可以分成3个步骤

获取一个指针，让它指向包含指定的块设备的address\_space对象(bdev->bd\_inode->imapping)

获取块设备的大小(bdev->bd\_block\_size)，并计算包含指定块的页索引。这需要在逻辑块号上进行移位操作，eg，如果块的大小是1024字节，每个缓冲区页包含4个块缓冲区，那么页的索引是nr/4

在块设备的基树中搜索缓冲区页，获得页描述符后，内核访问缓冲区首部，它描述了页中块缓冲区的状态

\_\_find\_get\_block(struct block\_device \*bdev, sector\_t block, unsigned size)

\_\_getblk(struct block\_device \*bdev, sector\_t block, unsigned size)

\_\_bread(struct block\_device \*bdev, sector\_t block, unsigned size)

交

块缓冲区最终要提交到通用块层进行IO操作，相关的API如下

int submit\_bh(int rw, struct buffer\_head \*bh)

void ll\_rw\_block(int rw, int nr, struct buffer\_head \*bhs\[\])

脏页回写

在脏页回写机制中，首先，内核使用一个backing\_dev\_info对象来描述一个bdi设备，即backing device info——非易失存储设备，这些backing\_dev\_info都会挂接到bdi\_list链表中，我们可以从其注册函数bdi\_register()中看出。由于bdi的低速，所以也就有了本文讨论的页缓冲机制以及脏页回写问题，当一个高速缓存页被修改时，内核就会将相应的page对象中的相应的tag置为PG\_dirty，即"脏页"，脏页需要在合适的时候回写到磁盘对于脏页回写，2.6.2x/3x以前的内核通过动态的创建/删除pdflush线程来实现脏页回写，但是2.6.2x/3x之后的内核对这个方面进行的改进，采用writeback机制进行回写，writeback机制需要的核心结构和方法的关系如下。

![65516c1e5aba1e0ec44cd53003b533fa.png][]

可以看出，一个逻辑磁盘--一个gendisk对象--一个request\_queue对象--一个backing\_dev\_info对象，这个backing\_dev\_info对象就是脏页回写的核心结构

64 struct backing\_dev\_info \{

65 struct list\_head bdi\_list;

97 struct bdi\_writeback wb; /\* default writeback info for this bdi \*/

100 struct list\_head work\_list;

102 struct device \*dev;

110 \};

struct backing\_dev\_info

\--65-->将所有的backing\_dev\_info链接起来的链表节点

\--97-->bdi\_writeback对象，使用延迟工作进行脏页回写

\--100-->这个bdi设备中等待被处理的页的描述

\--102-->表示这是一个device

37 /\*

38 \* Passed into wb\_writeback(), essentially a subset of writeback\_control

39 \*/

40 struct wb\_writeback\_work \{

41 long nr\_pages;

42 struct super\_block \*sb;

43 unsigned long \*older\_than\_this;

44 enum writeback\_sync\_modes sync\_mode;

45 unsigned int tagged\_writepages:1;

46 unsigned int for\_kupdate:1;

47 unsigned int range\_cyclic:1;

48 unsigned int for\_background:1;

49 unsigned int for\_sync:1; /\* sync(2) WB\_SYNC\_ALL writeback \*/

50 enum wb\_reason reason; /\* why was writeback initiated? \*/

52 struct list\_head list; /\* pending work list \*/

53 struct completion \*done; /\* set if the caller waits \*/

54 \};

51 struct bdi\_writeback \{

52 struct backing\_dev\_info \*bdi; /\* our parent bdi \*/

53 unsigned int nr;

55 unsigned long last\_old\_flush; /\* last old data flush \*/

57 struct delayed\_work dwork; /\* work item used for writeback \*/

58 struct list\_head b\_dirty; /\* dirty inodes \*/

59 struct list\_head b\_io; /\* parked for writeback \*/

60 struct list\_head b\_more\_io; /\* parked for more writeback \*/

61 spinlock\_t list\_lock; /\* protects the b\_\* lists \*/

62 \};

struct bdi\_writeback

\--57-->延迟工作对象，最终会调用下面的函数处理脏页

778 /\*

779 \* Explicit flushing or periodic writeback of "old" data.

780 \*

781 \* Define "old": the first time one of an inode's pages is dirtied, we mark the

782 \* dirtying-time in the inode's address\_space. So this periodic writeback code

783 \* just walks the superblock inode list, writing back any inodes which are

784 \* older than a specific point in time.

785 \*

786 \* Try to run once per dirty\_writeback\_interval. But if a writeback event

787 \* takes longer than a dirty\_writeback\_interval interval, then leave a

788 \* one-second gap.

789 \*

790 \* older\_than\_this takes precedence over nr\_to\_write. So we'll only write back

791 \* all dirty pages if they are all attached to "old" mappings.

792 \*/

793 static long wb\_writeback(struct bdi\_writeback \*wb,

794 struct wb\_writeback\_work \*work)

![0b1331709591d260c1c78e86d0c51c18.png][]

[da759dea0dc32024e70e02316c942148.png]: /images/20221020/b7f28d3f5e244dbd8adce03d1323b765.png
[5a08d1a39798165f72f93ae71a521dd2.png]: /images/20221020/8ef5767d52ef426191f8399d118c77b0.png
[65516c1e5aba1e0ec44cd53003b533fa.png]: /images/20221020/ba0841a00812493d8055d0d09e013b1a.png
[0b1331709591d260c1c78e86d0c51c18.png]: /images/20221020/eb645378c63c4b0caf7225240802e047.png