精华内容
下载资源
问答
  • Linux内核内存管理

    2009-08-24 14:49:02
    Linux内核内存管理,很全的内存管理讲解,自己手动整理的,绝对原创。
  • linux内核内存管理

    2014-11-05 14:59:59
    linux开发者介绍linux内存管理的机制,图文并茂,细致入里
  • linux内核内存管理图解
  • 给大家分享了关于Linux内核内存管理架构的相关知识点内容,有兴趣的朋友参考学习下。
  • linux 内核 内存管理

    千次阅读 2013-05-25 14:58:34
    内存管理应该是linux内核里最复杂的子系统之一。 涉及到的有mmu虚拟内存,内存映射,小内存slab 管理,文件系统到内存的映射,进程虚拟内存空间 等待等等。 一图胜千言 看了上面一幅图,在仔细理解下面一...

    内存管理应该是linux内核里最复杂的子系统之一。 涉及到的有mmu虚拟内存,内存映射,小内存slab 管理,文件系统到内存的映射,进程虚拟内存空间 等待等等。


    一图胜千言

    看了上面一幅图,在仔细理解下面一小段文字,对内存管理应该能理解个大概

    1. 内核初始化:

        * 内核建立好内核页目录页表数据库,假设物理内存大小为len,则建立了[3G--3G+len]::[0--len]这样的虚地址vaddr和物理地址paddr的线性对应关系;
        * 内核建立一个page数组,page数组和物理页面系列完全是线性对应,page用来管理该物理页面状态,每个物理页面的虚地址保存在page->virtual中;
        * 内核建立好一个free_list,将没有使用的物理页面对应的page放入其中,已经使用的就不用放入了;

    2. 内核模块申请内存vaddr = get_free_pages(mask,order):

        * 内存管理模块从free_list找到一个page,将page->virtual作为返回值,该返回值就是对应物理页面的虚地址;
        * 将page从free_list中脱离;
        * 模块使用该虚拟地址操作对应的物理内存;

    3. 内核模块使用vaddr,例如执行指令mov(eax, vaddr):

        * CPU获得vaddr这个虚地址,利用建立好的页目录页表数据库,找到其对应的物理内存地址;
        * 将eax的内容写入vaddr对应的物理内存地址内;

    4. 内核模块释放内存free_pages(vaddr,order):

        * 依据vaddr找到对应的page;
        * 将该page加入到free_list中;

    5. 用户进程申请内存vaddr = malloc(size):

        * 内存管理模块从用户进程内存空间(0--3G)中找到一块还没使用的空间vm_area_struct(start--end);
        * 随后将其插入到task->mm->mmap链表中;

    6. 用户进程写入vaddr(0-3G),例如执行指令mov(eax, vaddr):

        * CPU获得vaddr这个虚地址,该虚地址应该已经由glibc库设置好了,一定在3G一下的某个区域,根据CR3寄存器指向的current->pgd查当前进程的页目录页表数据库,发现该vaddr对应的页目录表项为0,故产生异常;
        * 在异常处理中,发现该vaddr对应的vm_area_struct已经存在,为vaddr对应的页目录表项分配一个页表;
        * 随后从free_list找到一个page,将该page对应的物理页面物理首地址赋给vaddr对应的页表表项,很明显,此时的vaddr和paddr不是线性对应关系了;
        * 将page从free_list中脱离;
        * 异常处理返回;
        * CPU重新执行刚刚发生异常的指令mov(eax, vaddr);
        * CPU获得vaddr这个虚地址,根据CR3寄存器指向的current->pgd,利用建立好的页目录页表数据库,找到其对应的物理内存地址;
        * 将eax的内容写入vaddr对应的物理内存地址内;  

    7. 用户进程释放内存vaddr,free(vaddr):

        * 找到该vaddr所在的vm_area_struct;
        * 找到vm_area_struct:start--end对应的所有页目录页表项,清空对应的所有页表项;
        * 释放这些页表项指向物理页面所对应的page,并将这些page加入到free_list队列中;
        * 有必要还会清空一些页目录表项,并释放这些页目录表项指向的页表;
        * 从task->mm->mmap链中删除该vm_area_struct并释放掉;

    综合说明:

        * 可用物理内存就是free_list中各page对应的物理内存;
        * 页目录页表数据库的主要目的是为CPU访问物理内存时转换vaddr-->paddr使用,分配以及释放内存时不会用到,但是需要内核内存管理系统在合适时机为CPU建立好该库;
        * 对于用户进程在6中获得的物理页面,有两个页表项对应,一个就是内核页目录页表数据库的某个pte[i ],一个就是当前进程内核页目录页表数据库的某个 pte[j],但是只有一个page和其对应。如果此时调度到其他进程,其他进程申请并访问某个内存,则不会涉及到该物理页面,因为其分配时首先要从 free_list中找一个page,而该物理页面对应的page已经从free_list中脱离出来了,因此不存在该物理页面被其他进程改写操作的情况。内核中通过get_free_pages等方式获取内存时,也不会涉及到该物理页面,原理同前所述。

    下面这篇博客对内存管理也进行了较为详细的描述,这幅图我太喜欢了,以后就就照着这个学习记忆内存管理了



    [ 地址映射 ](图:左中)
    linux内核使用页式内存管理,应用程序给出的内存地址是虚拟地址,它需要经过若干级页表一级一级的变换,才变成真正的物理地址。
    想一下,地址映射还是一件很恐怖的事情。当访问一个由虚拟地址表示的内存空间时,需要先经过若干次的内存访问,得到每一级页表中用于转换的页表项(页表是存放在内存里面的),才能完成映射。也就是说,要实现一次内存访问,实际上内存被访问了N+1次(N=页表级数),并且还需要做N次加法运算。
    所以,地址映射必须要有硬件支持,mmu(内存管理单元)就是这个硬件。并且需要有cache来保存页表,这个cache就是TLB(Translation lookaside buffer)。
    尽管如此,地址映射还是有着不小的开销。假设cache的访存速度是内存的10倍,命中率是40%,页表有三级,那么平均一次虚拟地址访问大概就消耗了两次物理内存访问的时间。
    于是,一些嵌入式硬件上可能会放弃使用mmu,这样的硬件能够运行VxWorks(一个很高效的嵌入式实时操作系统)、linux(linux也有禁用mmu的编译选项)、等系统。
    但是使用mmu的优势也是很大的,最主要的是出于 安全 性考虑。各个进程都是相互独立的虚拟地址空间,互不干扰。而放弃地址映射之后,所有程序将运行在同一个地址空间。于是,在没有mmu的机器上,一个进程越界访存,可能引起其他进程莫名其妙的错误,甚至导致内核崩溃。
    在地址映射这个问题上,内核只提供页表,实际的转换是由硬件去完成的。那么内核如何生成这些页表呢?这就有两方面的内容,虚拟地址空间的管理和物理内存的管理。(实际上只有用户态的地址映射才需要管理,内核态的地址映射是写死的。)

    [ 虚拟地址管理 ](图:左下)
    每个进程对应一个task结构,它指向一个mm结构,这就是该进程的内存管理器。(对于线程来说,每个线程也都有一个task结构,但是它们都指向同一个mm,所以地址空间是共享的。)
    mm->pgd指向容纳页表的内存,每个进程有自已的mm,每个mm有自己的页表。于是,进程调度时,页表被切换(一般会有一个CPU寄存器来保存页表的地址,比如X86下的CR3,页表切换就是改变该寄存器的值)。所以,各个进程的地址空间互不影响(因为页表都不一样了,当然无法访问到别人的地址空间上。但是共享内存除外,这是故意让不同的页表能够访问到相同的物理地址上)。
    用户程序对内存的操作(分配、回收、映射、等)都是对mm的操作,具体来说是对mm上的vma(虚拟内存空间)的操作。这些vma代表着进程空间的各个区域,比如堆、栈、代码区、数据区、各种映射区、等等。
    用户程序对内存的操作并不会直接影响到页表,更不会直接影响到物理内存的分配。比如malloc成功,仅仅是改变了某个vma,页表不会变,物理内存的分配也不会变。
    假设用户分配了内存,然后访问这块内存。由于页表里面并没有记录相关的映射,CPU产生一次缺页异常。内核捕捉异常,检查产生异常的地址是不是存在于一个合法的vma中。如果不是,则给进程一个"段错误",让其崩溃;如果是,则分配一个物理页,并为之建立映射。

    [ 物理内存管理 ](图:右上)
    那么物理内存是如何分配的呢?
    首先,linux支持NUMA(非均质存储结构),物理内存管理的第一个层次就是介质的管理。pg_data_t结构就描述了介质。一般而言,我们的内存管理介质只有内存,并且它是均匀的,所以可以简单地认为系统中只有一个pg_data_t对象。
    每一种介质下面有若干个zone。一般是三个,DMA、NORMAL和HIGH。
    DMA:因为有些硬件系统的DMA总线比系统总线窄,所以只有一部分地址空间能够用作DMA,这部分地址被管理在DMA区域(这属于是高级货了);
    HIGH:高端内存。在32位系统中,地址空间是4G,其中内核规定3~4G的范围是内核空间,0~3G是用户空间(每个用户进程都有这么大的虚拟空间)(图:中下)。前面提到过内核的地址映射是写死的,就是指这3~4G的对应的页表是写死的,它映射到了物理地址的0~1G上。(实际上没有映射1G,只映射了896M。剩下的空间留下来映射大于1G的物理地址,而这一部分显然不是写死的)。所以,大于896M的物理地址是没有写死的页表来对应的,内核不能直接访问它们(必须要建立映射),称它们为高端内存(当然,如果机器内存不足896M,就不存在高端内存。如果是64位机器,也不存在高端内存,因为地址空间很大很大,属于内核的空间也不止1G了);
    NORMAL:不属于DMA或HIGH的内存就叫NORMAL。
    在zone之上的zone_list代表了分配策略,即内存分配时的zone优先级。一种内存分配往往不是只能在一个zone里进行分配的,比如分配一个页给内核使用时,最优先是从NORMAL里面分配,不行的话就分配DMA里面的好了(HIGH就不行,因为还没建立映射),这就是一种分配策略。
    每个内存介质维护了一个mem_map,为介质中的每一个物理页面建立了一个page结构与之对应,以便管理物理内存。
    每个zone记录着它在mem_map上的起始位置。并且通过free_area串连着这个zone上空闲的page。物理内存的分配就是从这里来的,从 free_area上把page摘下,就算是分配了。(内核的内存分配与用户进程不同,用户使用内存会被内核监督,使用不当就"段错误";而内核则无人监督,只能靠自觉,不是自己从free_area摘下的page就不要乱用。)

    [ 建立地址映射 ]
    内核需要物理内存时,很多情况是整页分配的,这在上面的mem_map中摘一个page下来就好了。比如前面说到的内核捕捉缺页异常,然后需要分配一个page以建立映射。
    说到这里,会有一个疑问,内核在分配page、建立地址映射的过程中,使用的是虚拟地址还是物理地址呢?首先,内核代码所访问的地址都是虚拟地址,因为CPU指令接收的就是虚拟地址(地址映射对于CPU指令是透明的)。但是,建立地址映射时,内核在页表里面填写的内容却是物理地址,因为地址映射的目标就是要得到物理地址。
    那么,内核怎么得到这个物理地址呢?其实,上面也提到了,mem_map中的page就是根据物理内存来建立的,每一个page就对应了一个物理页。
    于是我们可以说,虚拟地址的映射是靠这里page结构来完成的,是它们给出了最终的物理地址。然而,page结构显然是通过虚拟地址来管理的(前面已经说过,CPU指令接收的就是虚拟地址)。那么,page结构实现了别人的虚拟地址映射,谁又来实现page结构自己的虚拟地址映射呢?没人能够实现。
    这就引出了前面提到的一个问题,内核空间的页表项是写死的。在内核初始化时,内核的地址空间就已经把地址映射写死了。page结构显然存在于内核空间,所以它的地址映射问题已经通过“写死”解决了。
    由于内核空间的页表项是写死的,又引出另一个问题,NORMAL(或DMA)区域的内存可能被同时映射到内核空间和用户空间。被映射到内核空间是显然的,因为这个映射已经写死了。而这些页面也可能被映射到用户空间的,在前面提到的缺页异常的场景里面就有这样的可能。映射到用户空间的页面应该优先从HIGH区域获取,因为这些内存被内核访问起来很不方便,拿给用户空间再合适不过了。但是HIGH区域可能会耗尽,或者可能因为设备上物理内存不足导致系统里面根本就没有HIGH区域,所以,将NORMAL区域映射给用户空间是必然存在的。
    但是NORMAL区域的内存被同时映射到内核空间和用户空间并没有问题,因为如果某个页面正在被内核使用,对应的page应该已经从free_area被摘下,于是缺页异常处理代码中不会再将该页映射到用户空间。反过来也一样,被映射到用户空间的page自然已经从free_area被摘下,内核不会再去使用这个页面。

    [ 内核空间管理 ](图:右下)
    除了对内存整页的使用,有些时候,内核也需要像用户程序使用malloc一样,分配一块任意大小的空间。这个功能是由slab系统来实现的。
    slab相当于为内核中常用的一些结构体对象建立了对象池,比如对应task结构的池、对应mm结构的池、等等。
    而slab也维护有通用的对象池,比如"32字节大小"的对象池、"64字节大小"的对象池、等等。内核中常用的kmalloc函数(类似于用户态的malloc)就是在这些通用的对象池中实现分配的。
    slab除了对象实际使用的内存空间外,还有其对应的控制结构。有两种组织方式,如果对象较大,则控制结构使用专门的页面来保存;如果对象较小,控制结构与对象空间使用相同的页面。
    除了slab,linux 2.6还引入了mempool(内存池)。其意图是:某些对象我们不希望它会因为内存不足而分配失败,于是我们预先分配若干个,放在mempool中存起来。正常情况下,分配对象时是不会去动mempool里面的资源的,照常通过slab去分配。到系统内存紧缺,已经无法通过slab分配内存时,才会使用 mempool中的内容。

    [ 页面换入换出 ](图:左上)(图:右上)
    页面换入换出又是一个很复杂的系统。内存页面被换出到磁盘,与磁盘文件被映射到内存,是很相似的两个过程(内存页被换出到磁盘的动机,就是今后还要从磁盘将其载回内存)。所以swap复用了文件子系统的一些机制。
    页面换入换出是一件很费CPU和IO的事情,但是由于内存昂贵这一历史原因,我们只好拿磁盘来扩展内存。但是现在内存越来越便宜了,我们可以轻松安装数G的内存,然后将swap系统关闭。于是swap的实现实在让人难有探索的欲望,在这里就不赘述了。(另见:《linux内核页面回收浅析》)

    [ 用户空间内存管理 ]
    malloc是libc的库函数,用户程序一般通过它(或类似函数)来分配内存空间。
    libc对内存的分配有两种途径,一是调整堆的大小,二是mmap一个新的虚拟内存区域(堆也是一个vma)。
    在内核中,堆是一个一端固定、一端可伸缩的vma(图:左中)。可伸缩的一端通过系统调用brk来调整。libc管理着堆的空间,用户调用malloc分配内存时,libc尽量从现有的堆中去分配。如果堆空间不够,则通过brk增大堆空间。
    当用户将已分配的空间free时,libc可能会通过brk减小堆空间。但是堆空间增大容易减小却难,考虑这样一种情况,用户空间连续分配了10块内存,前9块已经free。这时,未free的第10块哪怕只有1字节大,libc也不能够去减小堆的大小。因为堆只有一端可伸缩,并且中间不能掏空。而第10块内存就死死地占据着堆可伸缩的那一端,堆的大小没法减小,相关资源也没法归还内核。
    当用户malloc一块很大的内存时,libc会通过mmap系统调用映射一个新的vma。因为对于堆的大小调整和空间管理还是比较麻烦的,重新建一个vma会更方便(上面提到的free的问题也是原因之一)。
    那么为什么不总是在malloc的时候去mmap一个新的vma呢?第一,对于小空间的分配与回收,被libc管理的堆空间已经能够满足需要,不必每次都去进行系统调用。并且vma是以page为单位的,最小就是分配一个页;第二,太多的vma会降低系统性能。缺页异常、vma的新建与销毁、堆空间的大小调整、等等情况下,都需要对vma进行操作,需要在当前进程的所有vma中找到需要被操作的那个(或那些)vma。vma数目太多,必然导致性能下降。(在进程的vma较少时,内核采用链表来管理vma;vma较多时,改用红黑树来管理。)

    [ 用户的栈 ]
    与堆一样,栈也是一个vma(图:左中),这个vma是一端固定、一端可伸(注意,不能缩)的。这个vma比较特殊,没有类似brk的系统调用让这个vma伸展,它是自动伸展的。
    当用户访问的虚拟地址越过这个vma时,内核会在处理缺页异常的时候将自动将这个vma增大。内核会检查当时的栈寄存器(如:ESP),访问的虚拟地址不能超过ESP加n(n为CPU压栈指令一次性压栈的最大字节数)。也就是说,内核是以ESP为基准来检查访问是否越界。
    但是,ESP的值是可以由用户态程序自由读写的,用户程序如果调整ESP,将栈划得很大很大怎么办呢?内核中有一套关于进程限制的配置,其中就有栈大小的配置,栈只能这么大,再大就出错。
    对于一个进程来说,栈一般是可以被伸展得比较大(如:8MB)。然而对于线程呢?
    首先线程的栈是怎么回事?前面说过,线程的mm是共享其父进程的。虽然栈是mm中的一个vma,但是线程不能与其父进程共用这个vma(两个运行实体显然不用共用一个栈)。于是,在线程创建时,线程库通过mmap新建了一个vma,以此作为线程的栈(大于一般为:2M)。
    可见,线程的栈在某种意义上并不是真正栈,它是一个固定的区域,并且容量很有限。

    展开全文
  • Linux内核内存管理.zip

    2019-06-05 11:30:54
    linux内核中的内存管理方面的资料。物理内存映射成可操作的逻辑内存。
  • linux内核内存管理机制和改进,详细描述了linux内存的管理机制,对学习内存管理有很大的帮助,同时对了解linux的实现很有意。
  • 浅析linux内核内存管理之临时内核页表   临时页全局目录是在内核编译过程中静态地初始化的,而临时页表是由startup_32()汇编语言函数初始化的。临时页全局目录存放在swapper_pg_dir变量中...
                       浅析linux内核内存管理之临时内核页表 
    

                                                    



    临时页全局目录是在内核编译过程中静态地初始化的,而临时页表是由startup_32()汇编语言函数初始化的。临时页全局目录存放在swapper_pg_dir变量中,临时页表在pg0变量开始出存放,紧接在内核未初始化的数据段(_end符号后)后面。假设内存使用的段,临时页表和128KB的内存范围能容纳于RAM前8MB空间,为了映射8MB空间需要两个页表,一个是pg0处,另一个存放在pg0后边。为了在实模式和保护模式下都能对这8MB寻址,因此内核必须创建一个映射,把从0x00000000到0x007fffff的线性地址和从0xc0000000到0xc07fffff的线性地址映射到从0x00000000到0x007fffff。所以要设置临时页全局目录的第0,1,768,769项,其他项为0。


    临时内核页表设置的代码在arch/i386/kernel/head.S中:  

    [html]  view plain copy
    1.  91page_pde_offset = (__PAGE_OFFSET >> 20);  
    2.  92  
    3.  93        movl $(pg0 - __PAGE_OFFSET), %edi  
    4.  94        movl $(swapper_pg_dir - __PAGE_OFFSET), %edx  
    5.  95        movl $0x007, %eax                       /* 0x007 = PRESENT+RW+USER */  
    6.  9610:  
    7.  97        leal 0x007(%edi),%ecx                   /* Create PDE entry */  
    8.  98        movl %ecx,(%edx)                        /* Store identity PDE entry */  
    9.  99        movl %ecx,page_pde_offset(%edx)         /* Store kernel PDE entry */  
    10. 100        addl $4,%edx  
    11. 101        movl $1024, %ecx  
    12. 10211:  
    13. 103        stosl  
    14. 104        addl $0x1000,%eax  
    15. 105        loop 11b  
    16. 106        /* End condition: we must map up to and including INIT_MAP_BEYOND_END */  
    17. 107        /* bytes beyond the end of our own page tables; the +0x007 is the attribute bits */  
    18. 108        leal (INIT_MAP_BEYOND_END+0x007)(%edi),%ebp  
    19. 109        cmpl %ebp,%eax  
    20. 110        jb 10b  
    21. 111        movl %edi,(init_pg_tables_end - __PAGE_OFFSET)  
    91 计算__PAGE_OFFSET在页目录中的偏移
    93 %edi保存pg0的物理地址,pg0定义在连接脚本 arch/i386/kernel/vmlinux.lds中,gcc编译内核以后形成的符号地址都是虚拟地址,在我的系统redhat 9.0内核2.6.11环境下,pg0为 0xc04d4000,这个可以在System.map文件中查看到
    94 将swapper_pg_dir的物理地址存放到%edi中
    95 存放低12位的标志到%eax中
    97 将pg0的物理地址与标志位合到一起,创建一个页目录项
    98 将这个页目录项存储在swapper_pg_dir的临时页全局目录中,在第一次循环中填充0号表项,第二次循环填充1号表项
    99 在第一次循环填充768号表项,第二次循环填充769号表项
    100 edx指向下一个表项
    101 设置计数,即要设置临时页全局目录表1024个表项
    103 eax->[edi];edi = edi + 4
    104 填充pg0时,一个表项对应一个page,一个page是4KB,所以加0x1000
    105 一直循环,填充pg0的1024个表项;下一次大循环,填充pg0后边的那个页表的1024个表项
    108 将INIT_MAP_BEYOND_END+0x007+%edi与%ebp比较,如果小于就进行下一轮大循环,此时是填充pg0后的第二个页表
    111 init_pg_tables_end存放pg0+0x2000


    [html]  view plain copy
    1. 183/*  
    2. 184 * Enable paging  
    3. 185 */  
    4. 186        movl $swapper_pg_dir-__PAGE_OFFSET,%eax  
    5. 187        movl %eax,%cr3          /* set the page table pointer.. */  
    6. 188        movl %cr0,%eax  
    7. 189        orl $0x80000000,%eax  
    8. 190        movl %eax,%cr0          /* ..and set paging (PG) bit */  
    9. 191        ljmp $__BOOT_CS,$1f     /* Clear prefetch and normalize %eip */  
    10. 1921:  
    11. 193        /* Set up the stack pointer */  
    12. 194        lss stack_start,%esp  

    获得临时页全局目录的物理地址,存放在cr3中,并设置cr0的PG标志位,此时开启了分页功能
    展开全文
  • 浅析linux内核内存管理之PAE

    千次阅读 2012-04-15 20:12:42
    浅析linux内核内存管理之PAE    早期Intel处理器从80386到Pentium使用32位物理地址,理论上,这样可以访问4GB的RAM。然而,大型服务器需要大于4GB的RAM来同时运行数以千计的进程,近几年来这对Intel造成...

    浅析linux内核内存管理之PAE

                                                     

           早期Intel处理器从80386到Pentium使用32位物理地址,理论上,这样可以访问4GB的RAM。然而,大型服务器需要大于4GB的RAM来同时运行数以千计的进程,近几年来这对Intel造成了压力,所以必须扩展32位80x86所支持的RAM容量。

           Intel通过在它的处理器上把管脚数从32增加到36已经满足了这些需求,可以寻址64GB。同时引入了一种新的分页机制PAE(Physical Address Extension,物理地址扩展)把32位线性地址转换为36位物理地址才能使用所增加的物理内存,通过设置CR4的第5位来开启对PAE的支持。引入PAE就是为了访问大于4GB的RAM,线性地址仍然是32位,而物理地址是36位。

           64GB的RAM被分为2^24个页框,页表项的物理地址字段从20位扩展到了24位。PAE表项必须包含12个标志位和24个物理地址位,总数之和为36,页表项大小从32位变为64位。这样原来一个页框有1024个entry,现在有512个entry。开启PAE的80x86 32位使用的是三级页表,第一级是新引入的PDPT(页目录指针表,相当于PGD了),第二级是PMD,第三级是PTE。PDPT只有4个entry,每个对应1GB RAM,每个entry 是64位。CR3中有27位作为PDPT的起始地址。


    在开启PAE前,CR3中用20来存储页目录的起始地址;开启PAE后,用27位来存储page directory pointer table的起始地址。



    下边分两种情况来讨论,一个是PS=0,一个是PS=1:


    当CR4的第5位被置位(开启PAE),第4位被置位(开启PSE)




    • 线性地址31~30,用来指向一个PDPT的entry
    • 线性地址29~21,用来指向一个pmd的entry
    • 线性地址20~0,为4MB大页中的offset


    当CR4的第5位被置位(开启PAE),第4位被清除(关闭PSE)




    • 线性地址31~30,用来指向一个PDPT的entry
    • 线性地址29~21,用来指向一个pmd的entry
    • 线性地址20~12,用来指向一个pte
    • 线性地址11~0,为4KB页中的offset


    如何访问64GB?


    从上边的三级分页可以看到2^2*2^9*2^9*2^11=4GB,仍然访问的是4GB。访问64GB方法如下:

    • 修改CR3中的值使其指向不同的PDPT,这样就指向不同的4GB
    • 修改PDP entry中的值,使其指向不同的PMD表,这样可以指向不同的1GB

    但是实际上是不能访问这么大的内存的,实际可用的内存被限制在16GB,因为如果有64GB,那么每个struct page结构需要32字节,总共512MB,这样ZONE_NORMAL的内核地址空间就被大量占用,这样是不允许的。
    展开全文
  • 浅析linux内核内存管理之内存池

    千次阅读 2012-05-09 22:19:15
    内存池(memory pool)是linux 2.6的一个新特性。内核中有些地方的内存分配是不允许失败的。为了确保这种情况下的成功分配,内核开发者建立了一种称为内存池的抽象。内存池其实就是某种形式的后备高速缓存,它试图始终...

    内存池(memory pool)是linux 2.6的一个新特性。内核中有些地方的内存分配是不允许失败的。为了确保这种情况下的成功分配,内核开发者建立了一种称为内存池的抽象。内存池其实就是某种形式的后备高速缓存,它试图始终保存空闲的内存,以便在紧急状态下使用。下边是内存池对象的类型:

    [cpp]  view plain copy
    1. typedef struct mempool_s {  
    2.     spinlock_t lock;        /*用来保护对象字段的自旋锁*/  
    3.     int min_nr;     /*内存池中元素的最大个数*/  
    4.     int curr_nr;        /*当前内存池中元素的个数*/  
    5.     void **elements;        /*指向一个数组的指针,该数组由指向保留元素的指针组成*/  
    6.   
    7.   
    8.     void *pool_data;        /*池的拥有者可获得的私有数据*/  
    9.     mempool_alloc_t *alloc; /*分配一个元素的方法*/  
    10.     mempool_free_t *free;   /*释放一个元素的方法*/  
    11.     wait_queue_head_t wait; /*当内存池为空时使用的等待队列*/  
    12. } mempool_t;  
    下面介绍一些API,这些API的内核源码不过二百多行:

    创建内存池对象,mempool_create():

    [cpp]  view plain copy
    1. mempool_t * mempool_create(int min_nr, mempool_alloc_t *alloc_fn, mempool_free_t *free_fn, void *pool_data);  
    min_nr参数表示的是内存池应始终保持的已分配对象的最少数目,对象的实际分配和释放由alloc_fn和free_fn函数处理,其原型如下:

    [cpp]  view plain copy
    1. typedef void *(mempool_alloc_t)(int gfp_mask, void *pool_data);  
    2. typedef void mempool_free_t(void *element, void *pool_data);  
    mempool_create的最后一个参数,即pool_data,被传入alloc_fn和free_fn。

    在建立内存池之后,可如下所示分配和释放对象:

    [cpp]  view plain copy
    1. void *mempool_alloc(mempool_t *pool, int gfp_mask);  
    2. void mempool_free(void *element, mempool_t *pool);  
    在创建mempool时,就会多次调用分配函数为预先分配的对象创建内存池,创建的对象个数为min_nr的大小。之后,对mempool_alloc()的调用将首先通过分配函数获得该对象;如果该分配失败,就会返回预先分配的对象(如果存在的话)。如果使用mempool_free释放一个对象,则如果预先分配的对象数目小于要求的最低数目,就会将该对象保留在内存池中;否则,该对象会返回给系统。

    可以调用下面的函数来调整mempool的大小:

    [cpp]  view plain copy
    1. int mempool_resize(mempool_t *pool, int new_min_nr, int gfp_mask);  
    可以使用下面的函数将内存池返回给系统:
    [cpp]  view plain copy
    1. void mempool_destroy(mempool_t *pool);  
    在销毁mempool之前,必须将所有已分配的对象返回到内存池中,否则会导致内核oops。

    下边是自己编写的一个测试程序:

    [cpp]  view plain copy
    1. #include <linux/init.h>  
    2. #include <linux/module.h>  
    3. #include <linux/kernel.h>  
    4. #include <linux/slab.h>  
    5. #include <linux/errno.h>  
    6. #include <linux/mempool.h>  
    7. #include <linux/gfp.h>  
    8. #include <linux/delay.h>  
    9.   
    10. struct my_mempool{  
    11.     int val;  
    12. };  
    13. #define MY_MIN_MEMPOOL 20  
    14.   
    15. struct kmem_cache * mempool_cachep = NULL;  
    16. mempool_t * my_pool = NULL;  
    17. struct my_mempool * mempool_object = NULL;  
    18.   
    19. static int __init mempool_init(void){  
    20.     printk("memory pool test module init!\n");  
    21.     mempool_cachep = kmem_cache_create("mempool_cachep"sizeof(struct my_mempool), 0, 0, NULL);  
    22.     if(!mempool_cachep)  
    23.         return -ENOMEM;  
    24.     my_pool = mempool_create(MY_MIN_MEMPOOL, mempool_alloc_slab, mempool_free_slab, mempool_cachep);  
    25.     if(!my_pool)  
    26.         return -ENOMEM;  
    27.     mempool_object = (struct my_mempool *)mempool_alloc(my_pool, GFP_KERNEL);  
    28.     if(mempool_object)  
    29.         printk("one object has been allocated!\n");  
    30.     else  
    31.         goto fail;  
    32.     printk("memory pool curr_nr is %d, min_nr is %d\n", my_pool->curr_nr, my_pool->min_nr);  
    33.     mempool_free(mempool_object, my_pool);  
    34.     return 0;  
    35. fail:  
    36.     mempool_destroy(my_pool);  
    37.     kmem_cache_destroy(mempool_cachep);  
    38.     return -1;  
    39. }  
    40.   
    41. static void __exit mempool_exit(void){  
    42.     printk("memory pool test module exit!\n");  
    43.     if(my_pool){  
    44.         mempool_destroy(my_pool);  
    45.         printk("mempool has been destroy!\n");  
    46.     }  
    47.   
    48.     if(mempool_cachep){  
    49.         kmem_cache_destroy(mempool_cachep);  
    50.         printk("cache has been destroy!\n");  
    51.     }  
    52. }  
    53.   
    54. module_init(mempool_init);  
    55. module_exit(mempool_exit);  
    56. MODULE_AUTHOR("embeddedlwp@163.com");  
    57. MODULE_LICENSE("GPL");  
    这里创建了一个名为mempool_cachep的cache,然后又创建了一个memory pool,它的pool_data传的是指向cache的指针,表示这个memory pool是被用来保存slab对象的。这里分配一个object,然后cat /proc/slabinfo发现mempool_cachep的被使用object增加了1个,说明memory pool并没有从自己的那20个object中取得对象,而是从slab对象的cache中。其实,memory pool就相当于一种家里攒点钱留着保命的策略,在cache里有对象的时候就从cache分配,如果cache没有空闲object了,会调用cache_grow()分配新的slab。如果连cache都无法从系统获得slab了,那才开始使用那些为了保命攒下的“钱”。memory pool使用的那20个object是从slab的cache中分配的,所以释放的时候,要现释放memory pool,这样那20个object才会释放回cache,然后cache没有对象被使用才可以正确的释放了。
    展开全文
  • linux内核内存管理中的pagevec结构体

    千次阅读 2010-12-11 20:59:00
    linux内核内存管理中有一个2.6内核才加入的并不很张扬的结构体,那就是pagevec: struct pagevec {  unsigned long nr;  unsigned long cold;  struct page *pages[14];...
  • Linux内核内存管理算法Buddy和Slab

    千次阅读 2018-04-25 16:17:17
    有了前两节的学习相信读者已经知道CPU所有的操作都是建立在虚拟地址上处理(这里的虚拟地址分为内核态虚拟地址和用户态虚拟地址),CPU看到的内存管理都是对page的管理,接下来我们看一下用来管理page的经典算法--...
  • linux内核内存管理学习笔记

    千次阅读 2015-11-03 17:51:28
    内存管理: 物理地址出现在cpu外部地址总线上的寻址物理内存的地址信号 线程地址虚拟地址在32位cpu架构下4G地址空间中的地址 逻辑地址汇编中使用的地址   20位的虚拟地址如何存入16位的寄存器中呢 分段方式来...
  • linux 内核 内存管理 slub算法 (一) 原理

    万次阅读 多人点赞 2011-11-07 17:05:34
    内核管理页面使用了2个算法:伙伴算法和slub算法,伙伴...slub系统运行在伙伴系统之上,为内核提供小内存管理的功能。  slub把内存分组管理,每个组分别包含2^3、2^4、...2^11个字节,在4K页大小的默认情况下,另外
  • 深入浅出Linux内核内存管理基础

    千次阅读 2015-01-18 16:45:49
     从Linux操作系统层次上,内存可划分为用户空间内存内核空间内存。  32位的CPU,最大寻址范围为2^32 - 1也就是4G的线性地址空间。Linux简化了分段机制,使得虚拟地址与线性地址总是一致的。Linux一般把这个4G的...
  • linux内核中伙伴系统用来管理物理内存,其分配的单位是页,但是向用户程序一样,内核也需要动态分配内存,而伙伴系统分配的粒度又太大。由于内核无法借助标准的C库,因而需要别的手段来实现内核中动态内存的分配...
  • CPU被划分为多个节点(node),内存则被分簇,每个CPU对应一个本地物理内存,即CPU-node队形一个内存簇bank,即每个内存簇被认为一个节点。 系统的物理内存被划分为几个节点(node),一个node对应一个内存簇bank,即...
  • 浅析linux内核内存管理之kmalloc

    千次阅读 2012-05-09 22:48:39
    内核内存的通常分配方法,可能引起休眠。 GFP_USER 用于为用户空间分配内存,可能会引起休眠。 GFP_NOIO GFP_NOFS 这两个标志的功能类似于GFP_KERNEL,但是为内核分配内存的工作方式添加了一些限制。...
  • linux内核地址空间很大一块 是一一映射,这实际上不是必须的,而是内核想尽可能简单的实现内核本身的管理(迎合mmu,人家必须要mmu插手,你内核无法逃避,只好用最简单的方式应 付一下,如果没有mmu,那么对于内核...
  • 首先说说bootmem alloctor存在的意义。在内核刚刚开启分页机制时...为了尽快改变这种状况,内核创建了一个临时的内存管理器 -- bootmem alloctor,但这个内存管理模块的功能十分有限,内核随后会建立更强大的内存管理
  • Linux 操作系统和驱动程序运行在内核空间,应用程序运行在用户空间,两者... Linux内核地址空间划分 通常32位Linux内核地址空间划分0~3G为用户空间,3~4G为内核空间。注意这里是32位内核地址空间划分,64位内核地
  • linux使用伙伴系统来管理物理内存页。 一、伙伴系统原理 1. 伙伴关系 定义:由一个母实体分成的两个各方面属性一致的两个子实体,这两个子实体就处于伙伴关系。在操作系统分配内存的过程中,一个内存块常常被分成两...
  • 一、概述 1.虚拟地址空间 ...Linux内核将虚拟地址空间分成了两部分: 一部分是用户进程可用的,这部分地址是地址空间的低地址部分,从0到TASK_SIZE,称为用户空间一部分是由内核保留使用的,这部分地址是地
  • Linux内核内存管理探秘之四 虚拟内存的管理.pdf
  • linux内存管理--linux内核高端内存

    千次阅读 2014-04-12 20:28:32
    Linux内核地址映射模型 x86 CPU采用了段页式地址映射模型。进程代码中的地址为逻辑地址,经过段页式地址映射后,才真正访问物理内存。 段页式机制如下图。   Linux内核地址空间划分 ...Linux内核高端内存
  • Linux内核-内存管理之高端内存

    千次阅读 2013-06-06 13:19:11
    看了linux内核内存管理,参考网上的意见整理了一下,认为两个比较好的博文: http://blog.csdn.net/chobit_s/article/details/6029527 http://blog.csdn.net/do2jiang/article/details/5495675 1.页框管理  ...
  • linux 内核如何管理内存

    千次阅读 2015-07-30 01:51:46
    翻译自 ttp://duartes.org/gustavo/blog/post/how-the-... 在介绍完了进程虚拟地址空间的布局后, 我们来看一下内核是如何管理内存的:  linux的进程在内核中是由一个task_struct结构体描述的, 其中task_struct里面
  • linux内核开发-内存管理 详细讲解分页管理与分段管理,国嵌培训教材

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 220,072
精华内容 88,028
关键字:

linux内核内存管理

linux 订阅