Linux+page+cache+里的几个函数的源码分析

page cache 在linux vfs 中是比较重要的一层，其功能就不详细介绍了。主要介绍了几个关键性函数，容易帮助了解page cache里的整体逻辑和流程

先看一下page 的结构体

[cpp] view
plaincopy

/*

* Each physical page in the system has a struct page associated with

* it to keep track of whatever it is we are using the page for at the

* moment. Note that we have no way to track which tasks are using

* a page.

*/

struct page {

unsigned long flags; /* Atomic flags, some possibly

* updated asynchronously */

atomic_t _count; /* Usage count, see below. */

atomic_t _mapcount; /* Count of ptes mapped in mms,

* to show when page is mapped

* & limit reverse map searches.

*/

union {

struct {

unsigned long private; /* Mapping-private opaque data:

* usually used for buffer_heads

* if PagePrivate set; used for

* swp_entry_t if PageSwapCache;

* indicates order in the buddy

* system if PG_buddy is set.

*/

struct address_space *mapping; /* If low bit clear, points to

* inode address_space, or NULL.

* If page mapped as anonymous

* memory, low bit is set, and

* it points to anon_vma object:

* see PAGE_MAPPING_ANON below.

*/

};

#if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS

spinlock_t ptl;

#endif

};

pgoff_t index; /* Our offset within mapping. */

struct list_head lru; /* Pageout list, eg. active_list

* protected by zone->lru_lock !

*/

/*

* On machines where all RAM is mapped into kernel address space,

* we can simply calculate the virtual address. On machines with

* highmem some memory is mapped into kernel virtual memory

* dynamically, so we need a place to store that address.

* Note that this field could be 16 bits on x86 ... ;)

*

* Architectures with slow multiplication can define

* WANT_PAGE_VIRTUAL in asm/page.h

*/

#if defined(WANT_PAGE_VIRTUAL)

void *virtual; /* Kernel virtual address (NULL if

not kmapped, ie. highmem) */

#endif /* WANT_PAGE_VIRTUAL */

};

page_cache_get() 主要是调用函数get_page

[cpp] view
plaincopy

static inline void get_page(struct page *page)

{

if (unlikely(PageCompound(page)))

page = (struct page *)page_private(page);

atomic_inc(&page->_count);

}

主要page里的计数器+1，表示page引用的reference 次数

page_cache_release() 的核心函数 put_page_testzero

[java] view
plaincopy

static inline int put_page_testzero(struct page *page)

{

BUG_ON(atomic_read(&page->_count) == 0);

return atomic_dec_and_test(&page->_count);

}

显然是page的计数器-1, page的引用被释放

page 的flags 参数， 在page 的结构体里定义了flags参数，用bit位来标识page的状态，定义在page-flags.h文件里

这是在32位机 和 64位 系统的关于flags 定义

32 bit -------------------------------| FIELDS | FLAGS |

64 bit | FIELDS | ?????? FLAGS |

63 32 0

从bit0-bit19是常用的，其他位保留给了mapping zone, node and SPARSEMEM

[cpp] view
plaincopy

#define PG_locked 0 /* Page is locked. Don't touch. */

#define PG_error 1

#define PG_referenced 2

#define PG_uptodate 3

#define PG_dirty 4

#define PG_lru 5

#define PG_active 6

#define PG_slab 7 /* slab debug (Suparna wants this) */

#define PG_checked 8 /* kill me in 2.5.<early>. */

#define PG_arch_1 9

#define PG_reserved 10

#define PG_private 11 /* Has something at ->private */

#define PG_writeback 12 /* Page is under writeback */

#define PG_nosave 13 /* Used for system suspend/resume */

#define PG_compound 14 /* Part of a compound page */

#define PG_swapcache 15 /* Swap page: swp_entry_t in private */

#define PG_mappedtodisk 16 /* Has blocks allocated on-disk */

#define PG_reclaim 17 /* To be reclaimed asap */

#define PG_nosave_free 18 /* Free, should not be written */

#define PG_buddy 19 /* Page is free, on buddy lists */

SetPageUptodate 原子设置bit PG_uptodate 状态为1，表示改页被更新

#define SetPageUptodate(page) set_bit(PG_uptodate, &(page)->flags)

ClearPageUptodate 原子设置bit PG_uptodate 状态为0，表示页没有被更新

#define ClearPageUptodate(page) clear_bit(PG_uptodate, &(page)->flags)

TestSetPageLocked 设置原子设置page locked状态，并返回改变前的原来状态

[java] view
plaincopy

#define TestSetPageLocked(page) \

test_and_set_bit(PG_locked, &(page)->flags)

__lock_page 函数

[cpp] view
plaincopy

void fastcall __lock_page(struct page *page)

{

DEFINE_WAIT_BIT(wait, &page->flags, PG_locked);

__wait_on_bit_lock(page_waitqueue(page), &wait, sync_page,

TASK_UNINTERRUPTIBLE);

}

EXPORT_SYMBOL(__lock_page);

将当前进程设置成Task_uninterruptible状态，并将进程挂载到 wait对队列中，如果PG_Locked的状态为1时，触发sync_page的方法，只有在sync_page方法中才会调用schedule()调度当前进程，直到PG_locked的状态为0，注意当执行完__wait_on_bit_lock 的时候PG_locked仍然是1，因为__wait_on_bit_lock是用test_and_set_bit来进行while条件判断的,最后将进程设置成 TASK_RUNNING 状态，把该进程从wait
队列中移除。

unlock_page 函数

[cpp] view
plaincopy

void fastcall unlock_page(struct page *page)

{

smp_mb__before_clear_bit();

if (!TestClearPageLocked(page))

BUG();

smp_mb__after_clear_bit();

wake_up_page(page, PG_locked);

}

EXPORT_SYMBOL(unlock_page);

设置PG_Locked 的状态是0，遍历等待队列，执行唤醒函数

[cpp] view
plaincopy

static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,

int nr_exclusive, int sync, void *key)

{

struct list_head *tmp, *next;

list_for_each_safe(tmp, next, &q->task_list) {

wait_queue_t *curr = list_entry(tmp, wait_queue_t, task_list);

unsigned flags = curr->flags;

if (curr->func(curr, mode, sync, key) &&

(flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)

break;

}

}

其中func的定义是

[cpp] view
plaincopy

.func = autoremove_wake_function,

在autoremove_wake_function里，调用sched.c 的default_wake_function -> try_to_wake_up

将等待队列里的线程状态置为 TASK_RUNNING 并放置到运行队列中去