AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Linux高端内存映射(上)【转】

2017-11-10 1071
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
运维安全中心（堡垒机），企业双擎版|50资产|一周时长
运维安全中心（堡垒机），免费版 6个月
简介：

转自：http://blog.csdn.net/vanbreaker/article/details/7579941

版权声明：本文为博主原创文章，未经博主允许不得转载。

 
 

高端内存概述

        在32位的系统上，内核占有从第3GB~第4GB的线性地址空间，共1GB大小，内核将其中的前896MB与物理内存的0~896MB进行直接映射，即线性映射，将剩余的128M线性地址空间作为访问高于896M的内存的一个窗口。引入高端内存映射这样一个概念的主要原因就是我们所安装的内存大于1G时，内核的1G线性地址空间无法建立一个完全的直接映射来触及整个物理内存空间，而对于80x86开启PAE的情况下，允许的最大物理内存可达到64G，因此内核将自己的最后128M的线性地址空间腾出来，用以完成对高端内存的暂时性映射。而在64位的系统上就不存在这样的问题了，因为可用的线性地址空间远大于可安装的内存。下图描述了内核1GB线性地址空间是如何划分的

     

其中可以用来完成上述映射目的的区域为vmalloc area，Persistent kernel mappings区域和固定映射线性地址空间中的FIX_KMAP区域，这三个区域对应的映射机制分别为非连续内存分配，永久内核映射和临时内核映射。

 

永久内核映射

          在内核初始化页表管理机制时，专门用pkmap_page_table这个变量保存了PKMAP_BASE对应的页表项的地址，由pkmap_page_table来维护永久内核映射区的页表项的映射，页表项总数为LAST_PKMAP个，具体可以看前面关于页表机制初始化的博文。这里的永久并不是指调用kmap()建立的映射关系会一直持续下去无法解除，而是指在调用kunmap()解除映射之间这种映射会一直存在，这是相对于临时内核映射机制而言的。

       内核用一个pkmap_count数组来记录pkmap_page_table中每一个页表项的使用状态，其实就是为每个页表项分配一个计数器来记录相应的页表是否已经被用来映射。计数值分为以下三种情况：

计数值为0：对应的页表项没有映射高端内存，即为空闲可用的

计数值为1:   对应的页表项没有映射高端内存，但是不可用，因为上次映射后对应的TLB项还未被淸刷

计数值为n(n>1):对应的页表项已经映射了一个高端内存页框，并且有n-1个内核成分正在利用这种映射关系

 

下面结合代码进行具体的分析，先通过alloc_page(__GFP_HIGHMEM)分配到了一个属于高端内存区域的page结构，然后调用kmap(struct page*page)来建立与永久内核映射区的映射,需要注意一点的是，当永久内核映射区没有空闲的页表项可供映射时，请求映射的进程会被阻塞，因此永久内核映射请求不能发生在中断和可延迟函数中。

[cpp]  view plain  copy
 
  1. void *kmap(struct page *page)  
  2. {  
  3.     might_sleep();  
  4.     if (!PageHighMem(page))/*页框属于低端内存*/  
  5.         return page_address(page);/*返回页框的虚拟地址*/  
  6.     return kmap_high(page);  
  7. }  

如果页框是属于高端内存的话，则调用kmap_high()来建立映射

[cpp]  view plain  copy
 
  1. void *kmap_high(struct page *page)  
  2. {  
  3.     unsigned long vaddr;  
  4.   
  5.     /* 
  6.      * For highmem pages, we can't trust "virtual" until 
  7.      * after we have the lock. 
  8.      */  
  9.     lock_kmap();/*获取自旋锁防止多处理器系统上的并发访问*/  
  10.       
  11.     /*试图获取页面的虚拟地址,因为之前可能已经有进程为该页框建立了到永久内核映射区的映射*/  
  12.     vaddr = (unsigned long)page_address(page);  
  13.       
  14.     /*虚拟地址不存在则调用map_new_virtual()为该页框分配一个虚拟地址，完成映射*/  
  15.     if (!vaddr)  
  16.         vaddr = map_new_virtual(page);  
  17.     pkmap_count[PKMAP_NR(vaddr)]++;/*相应的页表项的计数值加1*/  
  18.     BUG_ON(pkmap_count[PKMAP_NR(vaddr)] < 2);  
  19.     unlock_kmap();  
  20.     return (void*) vaddr;  
  21. }  


如果该页框之前没被映射到永久内核映射区，则要通过map_new_virtual()函数在永久内核映射区对应的页表中找到一个空闲的表项来映射这个页框，简单的说就是为这个页框分配一个线性地址。

[cpp]  view plain  copy
 
  1. static inline unsigned long map_new_virtual(struct page *page)  
  2. {  
  3.     unsigned long vaddr;  
  4.     int count;  
  5.   
  6. start:  
  7.     /*LAST_PKMAP为永久映射区可以映射的页框数，在禁用PAE的情况下为512，开启PAE的情况下为1024， 
  8.     也就是说内核通过kmap,一次最多能映射2M/4M的高端内存*/  
  9.     count = LAST_PKMAP;  
  10.     /* Find an empty entry */  
  11.     for (;;) {  
  12.         /*last_pkmap_nr记录了上次遍历pkmap_count数组找到一个空闲页表项后的位置，首先从 
  13.         last_pkmap_nr出开始遍历，如果未能在pkmap_count中找到计数值为0的页表项,则last_pkmap_nr 
  14.         和LAST_PKMAP_MASK相与后又回到0，进行第二轮遍历*/  
  15.         last_pkmap_nr = (last_pkmap_nr + 1) & LAST_PKMAP_MASK;  
  16.   
  17.         /*last_pkmap_nr变为了0，也就是说第一次遍历中未能找到计数值为0的页表项*/  
  18.         if (!last_pkmap_nr) {  
  19.             flush_all_zero_pkmaps();  
  20.             count = LAST_PKMAP;  
  21.         }  
  22.         if (!pkmap_count[last_pkmap_nr])/*找到一个计数值为0的页表项，即空闲可用的页表项*/  
  23.             break;  /* Found a usable entry */  
  24.         if (--count)  
  25.             continue;  
  26.   
  27.         /* 
  28.          * Sleep for somebody else to unmap their entries 
  29.          */  
  30.          /*在pkmap_count数组中，找不到计数值为0或1的页表项，即所有页表项都被内核映射了， 
  31.             则声明一个等待队列，并将当前要求映射高端内存的进程添加到等待队列中然后 
  32.             阻塞该进程，等待其他的进程释放了KMAP区的某个页框的映射*/  
  33.         {  
  34.             DECLARE_WAITQUEUE(wait, current);  
  35.   
  36.             __set_current_state(TASK_UNINTERRUPTIBLE);  
  37.             add_wait_queue(&pkmap_map_wait, &wait);  
  38.             unlock_kmap();  
  39.             schedule();  
  40.             remove_wait_queue(&pkmap_map_wait, &wait);  
  41.             lock_kmap();  
  42.   
  43.             /* Somebody else might have mapped it while we slept */  
  44.             /*在睡眠的时候，可能有其他的进程映射了该页面，所以先试图获取页面的虚拟地址，成功的话直接返回*/                                 if(page_address(page))  
  45.                 return (unsigned long)page_address(page);  
  46.   
  47.             /* Re-start */  
  48.             goto start;/*唤醒后重新执行遍历操作*/  
  49.         }  
  50.     }  
  51.     /*寻找到了一个未被映射的页表项，获取该页表项对应的线性地址并赋给vaddr*/  
  52.     vaddr = PKMAP_ADDR(last_pkmap_nr);  
  53.     /*将pkmap_page_table中对应的pte设为申请映射的页框的pte,完成永久内核映射区中的页表项到物理页框的映射*/  
  54.     set_pte_at(&init_mm, vaddr,  
  55.            &(pkmap_page_table[last_pkmap_nr]), mk_pte(page, kmap_prot));  
  56.   
  57.     pkmap_count[last_pkmap_nr] = 1;  
  58.     /*设置页面的虚拟地址，将该页面添加到page_address_htable散列表中*/  
  59.     set_page_address(page, (void *)vaddr);  
  60.   
  61.     return vaddr;  
  62. }  


当第一趟遍历pkmap_count数组找不到计数值为0的页表项时，就要调用flush_all_zero_pkmaps(),将计数值为1的页表项置为0，撤销已经不用了的映射，并且刷新TLB

[cpp]  view plain  copy
 
  1. <span style="font-size:12px;">static void flush_all_zero_pkmaps(void)  
  2. {  
  3.     int i;  
  4.     int need_flush = 0;  
  5.   
  6.     flush_cache_kmaps();  
  7.   
  8.     for (i = 0; i < LAST_PKMAP; i++) {  
  9.         struct page *page;  
  10.   
  11.         /* 
  12.          * zero means we don't have anything to do, 
  13.          * >1 means that it is still in use. Only 
  14.          * a count of 1 means that it is free but 
  15.          * needs to be unmapped 
  16.          */  
  17.          /*将计数值为1的页面的计数值设为0，*/  
  18.         if (pkmap_count[i] != 1)  
  19.             continue;  
  20.         pkmap_count[i] = 0;  
  21.   
  22.         /* sanity check */  
  23.         BUG_ON(pte_none(pkmap_page_table[i]));  
  24.   
  25.         /* 
  26.          * Don't need an atomic fetch-and-clear op here; 
  27.          * no-one has the page mapped, and cannot get at 
  28.          * its virtual address (and hence PTE) without first 
  29.          * getting the kmap_lock (which is held here). 
  30.          * So no dangers, even with speculative execution. 
  31.          */  
  32.          /*撤销之前的映射关系，并将page从page_address_htable散列表中删除*/  
  33.         page = pte_page(pkmap_page_table[i]);  
  34.         pte_clear(&init_mm, (unsigned long)page_address(page),  
  35.               &pkmap_page_table[i]);  
  36.   
  37.         set_page_address(page, NULL);  
  38.         need_flush = 1;  
  39.     }  
  40.     if (need_flush)/*刷新TLB*/  
  41.         flush_tlb_kernel_range(PKMAP_ADDR(0), PKMAP_ADDR(LAST_PKMAP));  
  42. }</span>  

 

在map_new_virtual()中，当找到一个空闲页表后，还要调用set_page_address()将page与该页表项对应的线性地址进行关联，这里并不是简单的page结构中的virtual给赋上相应的值，而是将该映射的page添加到page_address_htable散列表中，该散列表维护着所有被映射到永久内核映射区的页框，散列表中的每一项记录了页框的page结构地址和映射页框的线性地址。

[cpp]  view plain  copy
 
  1. <span style="font-size:12px;">void set_page_address(struct page *page, void *virtual)  
  2. {  
  3.     unsigned long flags;  
  4.     struct page_address_slot *pas;  
  5.     struct page_address_map *pam;  
  6.   
  7.     BUG_ON(!PageHighMem(page));  
  8.   
  9.     pas = page_slot(page);  
  10.     if (virtual) {      /* Add */  
  11.         BUG_ON(list_empty(&page_address_pool));  
  12.   
  13.         spin_lock_irqsave(&pool_lock, flags);  
  14.         /*从page_address_pool中得到一个空闲的page_address_map*/  
  15.         pam = list_entry(page_address_pool.next,  
  16.                 struct page_address_map, list);  
  17.         list_del(&pam->list);/*将该节点从page_address_pool中删除*/  
  18.         spin_unlock_irqrestore(&pool_lock, flags);  
  19.   
  20.         /*将页框的page结构地址和虚拟地址保存到page_address_map中，可以看到并没有直接设定page的虚拟地址*/  
  21.         pam->page = page;  
  22.         pam->virtual = virtual;  
  23.   
  24.         spin_lock_irqsave(&pas->lock, flags);  
  25.         list_add_tail(&pam->list, &pas->lh);/*将pam添入散列表*/  
  26.         spin_unlock_irqrestore(&pas->lock, flags);  
  27.     } else {        /* Remove */ /*从散列表中删除一个节点，执行与上面相反的操作*/  
  28.         spin_lock_irqsave(&pas->lock, flags);  
  29.         list_for_each_entry(pam, &pas->lh, list) {  
  30.             if (pam->page == page) {  
  31.                 list_del(&pam->list);  
  32.                 spin_unlock_irqrestore(&pas->lock, flags);  
  33.                 spin_lock_irqsave(&pool_lock, flags);  
  34.                 list_add_tail(&pam->list, &page_address_pool);  
  35.                 spin_unlock_irqrestore(&pool_lock, flags);  
  36.                 goto done;  
  37.             }  
  38.         }  
  39.         spin_unlock_irqrestore(&pas->lock, flags);  
  40.     }  
  41. done:  
  42.     return;  
  43. }  
  44. </span>  



弄清楚了kmap()为页框建立永久内核映射，那么释放映射的话就容易理解了，当我们需要释放页框的映射时，调用kunmap()函数

[cpp]  view plain  copy
 
  1. <span style="font-size:12px;">void kunmap(struct page *page)  
  2. {  
  3.     if (in_interrupt())  
  4.         BUG();  
  5.     if (!PageHighMem(page))/*页框处于低端内存则直接返回*/  
  6.         return;  
  7.     kunmap_high(page);  
  8. }</span>  
[cpp]  view plain  copy
 
  1. <span style="font-size:12px;">void kunmap_high(struct page *page)  
  2. {  
  3.     unsigned long vaddr;  
  4.     unsigned long nr;  
  5.     unsigned long flags;  
  6.     int need_wakeup;  
  7.   
  8.     lock_kmap_any(flags);  
  9.     vaddr = (unsigned long)page_address(page);  
  10.     BUG_ON(!vaddr);  
  11.     nr = PKMAP_NR(vaddr);  
  12.   
  13.     /* 
  14.      * A count must never go down to zero 
  15.      * without a TLB flush! 
  16.      */  
  17.     need_wakeup = 0;  
  18.     switch (--pkmap_count[nr]) {/*该页面对应的页表项计数值减1*/  
  19.     case 0:  
  20.         BUG();  
  21.     case 1:  
  22.         /* 
  23.          * Avoid an unnecessary wake_up() function call. 
  24.          * The common case is pkmap_count[] == 1, but 
  25.          * no waiters. 
  26.          * The tasks queued in the wait-queue are guarded 
  27.          * by both the lock in the wait-queue-head and by 
  28.          * the kmap_lock.  As the kmap_lock is held here, 
  29.          * no need for the wait-queue-head's lock.  Simply 
  30.          * test if the queue is empty. 
  31.          */  
  32.         /*确定pkmap_map_wait等待队列是否为空*/  
  33.         need_wakeup = waitqueue_active(&pkmap_map_wait);  
  34.     }  
  35.     unlock_kmap_any(flags);  
  36.   
  37.     /* do wake-up, if needed, race-free outside of the spin lock */  
  38.     if (need_wakeup)/*等待队列不为空则唤醒其中的进程*/  
  39.         wake_up(&pkmap_map_wait);  
  40. }  
  41. </span>  

















本文转自张昺华-sky博客园博客，原文链接：http://www.cnblogs.com/sky-heaven/p/5662873.html，如需转载请自行联系原作者
文章标签：
运维安全中心（堡垒机）
Linux
C++
关键词：
Linux内存
内存映射
Linux映射
Linux内存映射
桃子红了呐
目录
相关文章
小王老师呀
|
2月前
|
安全 Linux Shell
Linux上执行内存中的脚本和程序
【9月更文挑战第3天】在 Linux 系统中，可以通过多种方式执行内存中的脚本和程序：一是使用 `eval` 命令直接执行内存中的脚本内容；二是利用管道将脚本内容传递给 `bash` 解释器执行；三是将编译好的程序复制到 `/dev/shm` 并执行。这些方法虽便捷，但也需谨慎操作以避免安全风险。
小王老师呀
182 6
光明顶阳顶天
|
6天前
|
缓存 Java Linux
如何解决 Linux 系统中内存使用量耗尽的问题？
如何解决 Linux 系统中内存使用量耗尽的问题？
光明顶阳顶天
73 48
光明顶阳顶天
|
6天前
|
缓存 Linux
如何检查 Linux 内存使用量是否耗尽？
何检查 Linux 内存使用量是否耗尽？
光明顶阳顶天
13 1
叫个什么名字
|
15天前
|
算法 Linux 开发者
深入探究Linux内核中的内存管理机制
本文旨在对Linux操作系统的内存管理机制进行深入分析，探讨其如何通过高效的内存分配和回收策略来优化系统性能。文章将详细介绍Linux内核中内存管理的关键技术点，包括物理内存与虚拟内存的映射、页面置换算法、以及内存碎片的处理方法等。通过对这些技术点的解析，本文旨在为读者提供一个清晰的Linux内存管理框架，帮助理解其在现代计算环境中的重要性和应用。
叫个什么名字
51 6
最好zzz
|
21天前
|
存储 缓存 监控
揭秘Linux内存缓存：性能优化的核心要素
【10月更文挑战第26天】
最好zzz
33 1
听风de歌
|
1月前
|
存储 缓存 监控
Linux中内存和性能问题
【10月更文挑战第5天】
听风de歌
39 4
听风de歌
|
1月前
|
算法 Linux
Linux中内存问题
【10月更文挑战第6天】
听风de歌
47 2
丰宝宝
|
18天前
|
缓存 算法 Linux
Linux内核中的内存管理机制深度剖析####
【10月更文挑战第28天】 本文深入探讨了Linux操作系统的心脏——内核，聚焦其内存管理机制的奥秘。不同于传统摘要的概述方式，本文将以一次虚拟的内存分配请求为引子，逐步揭开Linux如何高效、安全地管理着从微小嵌入式设备到庞大数据中心数以千计程序的内存需求。通过这段旅程，读者将直观感受到Linux内存管理的精妙设计与强大能力，以及它是如何在复杂多变的环境中保持系统稳定与性能优化的。 ####
丰宝宝
24 0
wljslmz
|
1月前
|
存储 缓存 固态存储
如何在 Linux 中清除缓冲区和缓存内存？
【10月更文挑战第7天】
wljslmz
70 0
如何在 Linux 中清除缓冲区和缓存内存？
穿过生命散发芬芳
|
2月前
|
存储 缓存 Linux
用户态内存映射
【9月更文挑战第20天】内存映射不仅包括物理与虚拟内存间的映射，还涉及将文件内容映射至虚拟内存，使得访问内存即可获取文件数据。mmap 系统调用支持将文件或匿名内存映射到进程的虚拟内存空间，通过多级页表机制实现高效地址转换，并利用 TLB 加速映射过程。TLB 作为页表缓存，存储频繁访问的页表项，显著提升了地址转换速度。
穿过生命散发芬芳
46 6

热门文章

最新文章

  • 1
    Redis 从入门到精通之内存和CPU配置优化
  • 2
    skywalking内存泄露排查
  • 3
    Java控制内存的功力
  • 4
    java-subString方法易导致内存溢出
  • 5
    Script:计算Oracle Streams进程所占用的内存大小
  • 6
    VS中捕获内存泄露
  • 7
    【Esper技术专题】带你进入事件驱动领域（内存计算、事件驱动、SQL支持）｜ 8月更文挑战
  • 8
    Java程序内存分析：使用mat工具分析内存占用
  • 9
    WinCE6.0内存分析工具
  • 10
    JVM内存模型及垃圾回收算法
  • 1
    Linux命令systemctl详解
    160
  • 2
    Linux命令sync详解
    476
  • 3
    Linux命令sum详解
    100
  • 4
    Linux命令su详解
    146
  • 5
    Linux命令stty详解
    391
  • 6
    Linux命令strip详解
    211
  • 7
    Linux命令strings详解
    220
  • 8
    stdbuf命令在Linux中的深度解析
    151
  • 9
    Linux命令stat：深入了解文件与文件系统状态
    223
  • 10
    Linux命令ssltap的深入解析与应用实践
    80

    • 相关课程

    更多
  • Linux高级网络应用 - 网络管理与配置实战
  • 计算机基础与Linux入门
  • Linux基本命令
  • Linux企业运维实战 - 入门及常用命令
  • Linux Shell 编程入门与实战
  • Linux网络进阶 - TCP/IP协议及OSI七层模型

    • 相关电子书

    更多
  • Alibaba Cloud Linux 3 技术揭秘
  • Alibaba Cloud Linux 3 发布
  • ECS系统指南之Linux系统诊断

    • 相关实验场景

    更多
  • Linux指令入门-文件与权限
  • Linux系统的文本处理
  • Linux指令入门-系统管理
  • 使用计算巢企业应用，一键获取专属的Linux服务器管理软件
  • Alibaba Cloud Linux操作系统的安装及使用
  • Alibaba Cloud Linux操作系统Shell程序

    • 推荐镜像

    更多
  • mxlinux-iso
  • archlinuxarm
  • archlinuxcn
    • 下一篇
    无影云桌面