linux高端内存管理之永久内核映射

三里屯摇滚

linux高端内存管理之永久内核映射

与直接映射的物理内存末端、高端内存的始端所对应的线性地址存放在high_memory变量中，在x86体系结构上，高于896MB的所有物理内存的范围大都是高端内存，它并不会永久地或自动地映射到内核地址空间，尽管x86处理器能够寻址物理RAM的范围达到4GB（启用PAE可以寻址到64GB)。一旦这些页被分配，就必须in射到内核的逻辑地址空间上。在x86上，高端内存中的页被映射到3GB-4GB。

内核可以采用三种不同的机制将页框映射到高端内存；分别叫做永久内核映射、临时内核映射以及非连续内存分配。在这里，只总结前两种技术，第三种技术将在后面总结。

建立永久内核映射可能阻塞当前进程；这发生在空闲页表项不存在时，也就是在高端内存上没有页表项可以用作页框的“窗口”时。因此，永久内核映射不能用于中断处理程序和可延迟函数。相反，建立临时内核映射绝不会要求阻塞当前进程；不过，他的缺点是只有很少的临时内核映射可以同时建立起来。

使用临时内核映射的内核控制路径必须保证当前没有其他的内核控制路径在使用同样地映射。这意味着内核控制路径永远不能被阻塞，后者其他内核控制路径有可能使用同一个窗口来映射其他的高端内存页。


永久内存映射

永久内核映射允许内核建立高端页框到内核地址空间的长期映射。他们使用住内核页表中一个专门的页表，其地址存放在变量pkmap_page_table中，这在前面的页表机制管理区初始化中已经介绍过了。页表中的表项数由LAST_PKMAP宏产生。因此，内核一次最多访问2MB或4MB的高端内存。

view plaincopy to clipboardprint?/*这里由定义可以看出永久内存映射为固定映射下面的4M空间*/  
#define PKMAP_BASE ((FIXADDR_BOOT_START - PAGE_SIZE * (LAST_PKMAP + 1)) \   
            & PMD_MASK)  
/*这里由定义可以看出永久内存映射为固定映射下面的4M空间*/
#define PKMAP_BASE ((FIXADDR_BOOT_START - PAGE_SIZE * (LAST_PKMAP + 1))        \
                    & PMD_MASK)
该页表映射的线性地址从PKMAP_BASE开始。pkmap_count数组包含LAST_PKMAP个计数器，pkmap_page_table页表中的每一项都有一个。

高端映射区逻辑页面的分配结构用分配表(pkmap_count)来描述，它有1024项，对应于映射区内不同的逻辑页面。当分配项的值等于0时为自由项，等于1时为缓冲项，大于1时为映射项。映射页面的分配基于分配表的扫描，当所有的自由项都用完时，系统将清除所有的缓冲项，如果连缓冲项都用完时，系统将进入等待状态。

view plaincopy to clipboardprint?/*
高端映射区逻辑页面的分配结构用分配表(pkmap_count)来描述，它有1024项，
对应于映射区内不同的逻辑页面。当分配项的值等于零时为自由项，等于1时为
缓冲项，大于1时为映射项。映射页面的分配基于分配表的扫描，当所有的自由
项都用完时，系统将清除所有的缓冲项，如果连缓冲项都用完时，系
统将进入等待状态。
*/  
static int pkmap_count[LAST_PKMAP];  
/*last_pkmap_nr：记录上次被分配的页表项在pkmap_page_table里的位置，初始值为０，所以第一次分配的时候last_pkmap_nr等于１*/  
static unsigned int last_pkmap_nr;  
/*
高端映射区逻辑页面的分配结构用分配表(pkmap_count)来描述，它有1024项，
对应于映射区内不同的逻辑页面。当分配项的值等于零时为自由项，等于1时为
缓冲项，大于1时为映射项。映射页面的分配基于分配表的扫描，当所有的自由
项都用完时，系统将清除所有的缓冲项，如果连缓冲项都用完时，系
统将进入等待状态。
*/
static int pkmap_count[LAST_PKMAP];
/*last_pkmap_nr：记录上次被分配的页表项在pkmap_page_table里的位置，初始值为０，所以第一次分配的时候last_pkmap_nr等于１*/
static unsigned int last_pkmap_nr;
为了记录高端内存页框与永久内核映射包含的线性地址之间的联系，内核使用了page_address_htable散列表。该表包含一个page_address_map数据结构，用于为高端内存中的每一个页框进行当前映射。而该数据结构还包含一个指向页描述符的指针和分配给该页框的线性地址。

1. view plaincopy to clipboardprint? * Hash table bucket  
   
2. */  
   
3. static struct page_address_slot {  
   
4.     struct list_head lh;            /* List of page_address_maps */  
   
5.     spinlock_t lock;            /* Protect this bucket's list */  
   
6. } ____cacheline_aligned_in_smp page_address_htable[1<<PA_HASH_ORDER];  
   
7.   
   
8. /*
   
9. * Describes one page->virtual association
   
10. */  
    
11. struct page_address_map {  
    
12.     struct page *page;  
    
13.     void *virtual;  
    
14.     struct list_head list;  
    
15. };  
    
16. * Hash table bucket
    
17. */
    
18. static struct page_address_slot {
    
19.         struct list_head lh;                        /* List of page_address_maps */
    
20.         spinlock_t lock;                        /* Protect this bucket's list */
    
21. } ____cacheline_aligned_in_smp page_address_htable[1<<PA_HASH_ORDER];
    
22. 
    
23. /*
    
24. * Describes one page->virtual association
    
25. */
    
26. struct page_address_map {
    
27.         struct page *page;
    
28.         void *virtual;
    
29.         struct list_head list;
    
30. };
    
31. page_address()函数返回页框对应的线性地址
    
32. 
    
33. view plaincopy to clipboardprint? * Returns the page's virtual address.  
    
34. */  
    
35. /*返回页框对应的线性地址*/  
    
36. void *page_address(struct page *page)  
    
37. {  
    
38.     unsigned long flags;  
    
39.     void *ret;  
    
40.     struct page_address_slot *pas;  
    
41.     /*如果页框不在高端内存中*/  
    
42.     if (!PageHighMem(page))  
    
43.         /*线性地址总是存在，通过计算页框下标
    
44.         然后将其转换成物理地址，最后根据相应的
    
45.         物理地址得到线性地址*/  
    
46.         return lowmem_page_address(page);  
    
47.     /*从page_address_htable散列表中得到pas*/  
    
48.     pas = page_slot(page);  
    
49.     ret = NULL;  
    
50.     spin_lock_irqsave(&pas->lock, flags);  
    
51.     if (!list_empty(&pas->lh)) {/*如果对应的链表不空，
    
52.     该链表中存放的是page_address_map结构*/  
    
53.         struct page_address_map *pam;  
    
54.         /*对每个链表中的元素*/  
    
55.         list_for_each_entry(pam, &pas->lh, list) {  
    
56.             if (pam->page == page) {  
    
57.                 ret = pam->virtual;/*返回线性地址*/  
    
58.                 goto done;  
    
59.             }  
    
60.         }  
    
61.     }  
    
62. done:  
    
63.     spin_unlock_irqrestore(&pas->lock, flags);  
    
64.     return ret;  
    
65. }  
    
66. * Returns the page's virtual address.
    
67. */
    
68. /*返回页框对应的线性地址*/
    
69. void *page_address(struct page *page)
    
70. {
    
71.         unsigned long flags;
    
72.         void *ret;
    
73.         struct page_address_slot *pas;
    
74.         /*如果页框不在高端内存中*/
    
75.         if (!PageHighMem(page))
    
76.                 /*线性地址总是存在，通过计算页框下标
    
77.                 然后将其转换成物理地址，最后根据相应的
    
78.                 物理地址得到线性地址*/
    
79.                 return lowmem_page_address(page);
    
80.         /*从page_address_htable散列表中得到pas*/
    
81.         pas = page_slot(page);
    
82.         ret = NULL;
    
83.         spin_lock_irqsave(&pas->lock, flags);
    
84.         if (!list_empty(&pas->lh)) {/*如果对应的链表不空，
    
85.         该链表中存放的是page_address_map结构*/
    
86.                 struct page_address_map *pam;
    
87.                 /*对每个链表中的元素*/
    
88.                 list_for_each_entry(pam, &pas->lh, list) {
    
89.                         if (pam->page == page) {
    
90.                                 ret = pam->virtual;/*返回线性地址*/
    
91.                                 goto done;
    
92.                         }
    
93.                 }
    
94.         }
    
95. done:
    
96.         spin_unlock_irqrestore(&pas->lock, flags);
    
97.         return ret;
    
98. }
    
99. kmap()函数建立永久内核映射。
    
100. 
     
101. view plaincopy to clipboardprint?/*高端内存映射，运用数组进行操作分配情况
     
102. 分配好后需要加入哈希表中；*/  
     
103. void *kmap(struct page *page)  
     
104. {  
     
105.     might_sleep();  
     
106.     if (!PageHighMem(page))/*如果页框不属于高端内存*/  
     
107.         return page_address(page);  
     
108.     return kmap_high(page);/*页框确实属于高端内存*/  
     
109. }  
     
110. /*高端内存映射，运用数组进行操作分配情况
     
111. 分配好后需要加入哈希表中；*/
     
112. void *kmap(struct page *page)
     
113. {
     
114.         might_sleep();
     
115.         if (!PageHighMem(page))/*如果页框不属于高端内存*/
     
116.                 return page_address(page);
     
117.         return kmap_high(page);/*页框确实属于高端内存*/
     
118. }view plaincopy to clipboardprint?/**
     
119. * kmap_high - map a highmem page into memory
     
120. * @page: &struct page to map
     
121. *
     
122. * Returns the page's virtual memory address.
     
123. *
     
124. * We cannot call this from interrupts, as it may block.
     
125. */  
     
126. void *kmap_high(struct page *page)  
     
127. {  
     
128.     unsigned long vaddr;  
     
129.   
     
130.     /*
     
131.      * For highmem pages, we can't trust "virtual" until
     
132.      * after we have the lock.
     
133.      */  
     
134.     lock_kmap();/*保护页表免受多处理器系统上的
     
135.     并发访问*/  
     
136.     /*检查是否已经被映射*/  
     
137.     vaddr = (unsigned long)page_address(page);  
     
138.     if (!vaddr)/*如果没有*/  
     
139.         /*把页框的物理地址插入到pkmap_page_table的
     
140.         一个项中并在page_address_htable散列表中加入一个
     
141.         元素*/  
     
142.         vaddr = map_new_virtual(page);  
     
143.     pkmap_count[PKMAP_NR(vaddr)]++;/*分配计数加一，此时流程都正确应该是2了*/  
     
144.     BUG_ON(pkmap_count[PKMAP_NR(vaddr)] < 2);  
     
145.     unlock_kmap();  
     
146.     return (void*) vaddr;/*返回地址*/  
     
147. }  
     
148. /**
     
149. * kmap_high - map a highmem page into memory
     
150. * @page: &struct page to map
     
151. *
     
152. * Returns the page's virtual memory address.
     
153. *
     
154. * We cannot call this from interrupts, as it may block.
     
155. */
     
156. void *kmap_high(struct page *page)
     
157. {
     
158.         unsigned long vaddr;
     
159. 
     
160.         /*
     
161.          * For highmem pages, we can't trust "virtual" until
     
162.          * after we have the lock.
     
163.          */
     
164.         lock_kmap();/*保护页表免受多处理器系统上的
     
165.         并发访问*/
     
166.         /*检查是否已经被映射*/
     
167.         vaddr = (unsigned long)page_address(page);
     
168.         if (!vaddr)/*如果没有*/
     
169.                 /*把页框的物理地址插入到pkmap_page_table的
     
170.                 一个项中并在page_address_htable散列表中加入一个
     
171.                 元素*/
     
172.                 vaddr = map_new_virtual(page);
     
173.         pkmap_count[PKMAP_NR(vaddr)]++;/*分配计数加一，此时流程都正确应该是2了*/
     
174.         BUG_ON(pkmap_count[PKMAP_NR(vaddr)] < 2);
     
175.         unlock_kmap();
     
176.         return (void*) vaddr;/*返回地址*/
     
177. }view plaincopy to clipboardprint?static inline unsigned long map_new_virtual(struct page *page)  
     
178. {  
     
179.     unsigned long vaddr;  
     
180.     int count;  
     
181.   
     
182. start:  
     
183.     count = LAST_PKMAP;  
     
184.     /* Find an empty entry */  
     
185.     for (;;) {  
     
186.         /*加1，防止越界*/  
     
187.         last_pkmap_nr = (last_pkmap_nr + 1) & LAST_PKMAP_MASK;  
     
188.         /*
     
189.         接下来判断什么时候last_pkmap_nr等于０，等于０就表示1023（LAST_PKMAP(1024)-1）个页表项已经被分配了
     
190.         ,这时候就需要调用flush_all_zero_pkmaps()函数,把所有pkmap_count[] 计数为1的页表项在TLB里面的entry给flush掉
     
191.         ，并重置为0，这就表示该页表项又可以用了，可能会有疑惑为什么不在把pkmap_count置为1的时候也
     
192.         就是解除映射的同时把TLB也flush呢？
     
193.         个人感觉有可能是为了效率的问题吧，毕竟等到不够的时候再刷新，效率要好点吧。
     
194.         */  
     
195.         if (!last_pkmap_nr) {  
     
196.             flush_all_zero_pkmaps();  
     
197.             count = LAST_PKMAP;  
     
198.         }  
     
199.         if (!pkmap_count[last_pkmap_nr])  
     
200.             break;  /* Found a usable entry */  
     
201.         if (--count)  
     
202.             continue;  
     
203.   
     
204.         /*
     
205.          * Sleep for somebody else to unmap their entries
     
206.          */  
     
207.         {  
     
208.             DECLARE_WAITQUEUE(wait, current);  
     
209.   
     
210.             __set_current_state(TASK_UNINTERRUPTIBLE);  
     
211.             add_wait_queue(&pkmap_map_wait, &wait);  
     
212.             unlock_kmap();  
     
213.             schedule();  
     
214.             remove_wait_queue(&pkmap_map_wait, &wait);  
     
215.             lock_kmap();  
     
216.   
     
217.             /* Somebody else might have mapped it while we slept */  
     
218.             if (page_address(page))  
     
219.                 return (unsigned long)page_address(page);  
     
220.   
     
221.             /* Re-start */  
     
222.             goto start;  
     
223.         }  
     
224.     }  
     
225.     /*返回这个页表项对应的线性地址vaddr.*/  
     
226.     vaddr = PKMAP_ADDR(last_pkmap_nr);  
     
227. /*
     
228. v
     
229.     set_pte_at(mm, addr, ptep, pte)函数在NON-PAE i386上的实现其实很简单，其实就等同于下面的代码：
     
230.      
     
231.     static inline void native_set_pte(pte_t *ptep , pte_t pte)
     
232.     {
     
233.            *ptep = pte;
     
234.     }
     
235. */  set_pte_at(&init_mm, vaddr,/*设置页表项*/  
     
236.            &(pkmap_page_table[last_pkmap_nr]), mk_pte(page, kmap_prot));  
     
237.     /*接下来把pkmap_count[last_pkmap_nr]置为1，1不是表示不可用吗，
     
238.     既然映射已经建立好了，应该赋值为2呀，其实这个操作
     
239.     是在他的上层函数kmap_high里面完成的(pkmap_count[PKMAP_NR(vaddr)]++).*/  
     
240.     pkmap_count[last_pkmap_nr] = 1;  
     
241.     /*到此为止，整个映射就完成了，再把page和对应的线性地址
     
242.     加入到page_address_htable哈希链表里面就可以了*/  
     
243.     set_page_address(page, (void *)vaddr);  
     
244.   
     
245.     return vaddr;  
     
246. }  
     
247. static inline unsigned long map_new_virtual(struct page *page)
     
248. {
     
249.         unsigned long vaddr;
     
250.         int count;
     
251. 
     
252. start:
     
253.         count = LAST_PKMAP;
     
254.         /* Find an empty entry */
     
255.         for (;;) {
     
256.                 /*加1，防止越界*/
     
257.                 last_pkmap_nr = (last_pkmap_nr + 1) & LAST_PKMAP_MASK;
     
258.                 /*
     
259.                 接下来判断什么时候last_pkmap_nr等于０，等于０就表示1023（LAST_PKMAP(1024)-1）个页表项已经被分配了
     
260.                 ,这时候就需要调用flush_all_zero_pkmaps()函数,把所有pkmap_count[] 计数为1的页表项在TLB里面的entry给flush掉
     
261.                 ，并重置为0，这就表示该页表项又可以用了，可能会有疑惑为什么不在把pkmap_count置为1的时候也
     
262.                 就是解除映射的同时把TLB也flush呢？
     
263.                 个人感觉有可能是为了效率的问题吧，毕竟等到不够的时候再刷新，效率要好点吧。
     
264.                 */
     
265.                 if (!last_pkmap_nr) {
     
266.                         flush_all_zero_pkmaps();
     
267.                         count = LAST_PKMAP;
     
268.                 }
     
269.                 if (!pkmap_count[last_pkmap_nr])
     
270.                         break;        /* Found a usable entry */
     
271.                 if (--count)
     
272.                         continue;
     
273. 
     
274.                 /*
     
275.                  * Sleep for somebody else to unmap their entries
     
276.                  */
     
277.                 {
     
278.                         DECLARE_WAITQUEUE(wait, current);
     
279. 
     
280.                         __set_current_state(TASK_UNINTERRUPTIBLE);
     
281.                         add_wait_queue(&pkmap_map_wait, &wait);
     
282.                         unlock_kmap();
     
283.                         schedule();
     
284.                         remove_wait_queue(&pkmap_map_wait, &wait);
     
285.                         lock_kmap();
     
286. 
     
287.                         /* Somebody else might have mapped it while we slept */
     
288.                         if (page_address(page))
     
289.                                 return (unsigned long)page_address(page);
     
290. 
     
291.                         /* Re-start */
     
292.                         goto start;
     
293.                 }
     
294.         }
     
295.         /*返回这个页表项对应的线性地址vaddr.*/
     
296.         vaddr = PKMAP_ADDR(last_pkmap_nr);
     
297. /*
     
298. v
     
299.         set_pte_at(mm, addr, ptep, pte)函数在NON-PAE i386上的实现其实很简单，其实就等同于下面的代码：
     
300.        
     
301.         static inline void native_set_pte(pte_t *ptep , pte_t pte)
     
302.         {
     
303.                    *ptep = pte;
     
304.         }
     
305. */        set_pte_at(&init_mm, vaddr,/*设置页表项*/
     
306.                    &(pkmap_page_table[last_pkmap_nr]), mk_pte(page, kmap_prot));
     
307.         /*接下来把pkmap_count[last_pkmap_nr]置为1，1不是表示不可用吗，
     
308.         既然映射已经建立好了，应该赋值为2呀，其实这个操作
     
309.         是在他的上层函数kmap_high里面完成的(pkmap_count[PKMAP_NR(vaddr)]++).*/
     
310.         pkmap_count[last_pkmap_nr] = 1;
     
311.         /*到此为止，整个映射就完成了，再把page和对应的线性地址
     
312.         加入到page_address_htable哈希链表里面就可以了*/
     
313.         set_page_address(page, (void *)vaddr);
     
314. 
     
315.         return vaddr;
     
316. }

复制代码

kunmap()函数撤销先前由kmap()建立的永久内核映射

如果页确实在高端内存中，则调用kunmap_high()函数

1. view plaincopy to clipboardprint? * kunmap_high - map a highmem page into memory  
   
2. * @page: &struct page to unmap  
   
3. *  
   
4. * If ARCH_NEEDS_KMAP_HIGH_GET is not defined then this may be called  
   
5. * only from user context.  
   
6. */  
   
7. void kunmap_high(struct page *page)  
   
8. {  
   
9.     unsigned long vaddr;  
   
10.     unsigned long nr;  
    
11.     unsigned long flags;  
    
12.     int need_wakeup;  
    
13.   
    
14.     lock_kmap_any(flags);  
    
15.     vaddr = (unsigned long)page_address(page);  
    
16.     BUG_ON(!vaddr);  
    
17.     nr = PKMAP_NR(vaddr);/*永久内存区域开始的第几个页面*/  
    
18.   
    
19.     /*
    
20.      * A count must never go down to zero
    
21.      * without a TLB flush!
    
22.      */  
    
23.     need_wakeup = 0;  
    
24.     switch (--pkmap_count[nr]) {/*减小这个值，因为在映射的时候对其进行了加2*/  
    
25.     case 0:  
    
26.         BUG();  
    
27.     case 1:  
    
28.         /*
    
29.          * Avoid an unnecessary wake_up() function call.
    
30.          * The common case is pkmap_count[] == 1, but
    
31.          * no waiters.
    
32.          * The tasks queued in the wait-queue are guarded
    
33.          * by both the lock in the wait-queue-head and by
    
34.          * the kmap_lock.  As the kmap_lock is held here,
    
35.          * no need for the wait-queue-head's lock.  Simply
    
36.          * test if the queue is empty.
    
37.          */  
    
38.         need_wakeup = waitqueue_active(&pkmap_map_wait);  
    
39.     }  
    
40.     unlock_kmap_any(flags);  
    
41.   
    
42.     /* do wake-up, if needed, race-free outside of the spin lock */  
    
43.     if (need_wakeup)  
    
44.         wake_up(&pkmap_map_wait);  
    
45. }  

复制代码

小忻黑夜

谢谢分享