Linux - 内存管理

最新推荐文章于 2024-06-11 23:54:48 发布
最新推荐文章于 2024-06-11 23:54:48 发布
阅读量557 收藏 10
点赞数 1
分类专栏： linux 内存管理 文章标签： linux 内存管理 mmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vertor11/article/details/104593050
版权

 引用文章

一. 用户进程内存管理

1.1 进程的虚拟地址空间VMA

1.2 进程的pmap

1.3 VMA与程序的各个段以及库关系

1.4 VSS, RSS, PSS, USS的关系

1.5 page fault的几种可能性

1.6 进程内存泄漏的界定

1.7 内存泄漏的检查

二. 内核内存管理

2.1 内存分布

2.2 内存管理图

 

三. 用户空间和内核空间内存分配关系

3.1 内存总体关系图

3.2 Libc, Slab与buddy

3.3 kmalloc VS vmalloc/ioremap

四. 一个mmap的小实验

4.1 kernel driver

#include <linux/version.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mm.h>
#ifdef MODVERSIONS
#include <linux/modversions.h>
#endif
#include <asm/io.h>
#include <linux/device.h>

/* length of the two memory areas */
#define NPAGES 16

struct mmap_dev_info_st {
    /* char device */
    dev_t mmap_dev;
    struct cdev mmap_cdev;
    
    struct class *mmap_class;
    
    
    /* pointer to the vmalloc'd area - alway page aligned */
    int *vmalloc_area;

    /* pointer to the kmalloc'd area, rounded up to a page boundary */
    int *kmalloc_area;

    /* original pointer for kmalloc'd area as returned by kmalloc */
    void *kmalloc_ptr;
};

static struct mmap_dev_info_st mmap_dev_info;


static int mmap_open(struct inode *inode, struct file *filp)
{
    return 0;
}

static int mmap_release(struct inode *inode, struct file *filp)
{
    return 0;
}

/* mmap's the kmalloc'd area which is physically contiguous */
int mmap_kmem(struct file *filp, struct vm_area_struct *vma)
{
    int ret = 0;
    long length = vma->vm_end - vma->vm_start;
    int *kmalloc_area = mmap_dev_info.kmalloc_area;
    
    printk(KERN_ERR "%s: start\n", __func__);

    /* check length - do not allow larger mappings than the number of
       pages allocated */
    if (length > NPAGES * PAGE_SIZE) {
        ret = -EIO;
        printk(KERN_ERR "%s: length err.\n", __func__);
        goto err;
    }

    /* map the whole physically contiguous area in one piece */
    ret = remap_pfn_range(vma, vma->vm_start,
                    virt_to_phys((void *)kmalloc_area) >> PAGE_SHIFT,
                    length, vma->vm_page_prot);
    if (ret < 0) {
        printk(KERN_ERR "%s: ret:%d err.\n", __func__, ret);
        goto err;
    }
    
    return 0;

err:
    return ret;
}

/* mmap's the vmalloc'd area which is not physically contiguous */
int mmap_vmem(struct file *filp, struct vm_area_struct *vma)
{
    int ret = 0;
    long length = vma->vm_end - vma->vm_start;
    unsigned long start = vma->vm_start;
    char *vmalloc_area_ptr = (char *)mmap_dev_info.vmalloc_area;
    unsigned long pfn = 0;

    printk(KERN_ERR "%s: start\n", __func__);

    /* check length - do not allow larger mappings than the number of
       pages allocated */
    if (length > NPAGES * PAGE_SIZE) {
        ret = -EIO;
        printk(KERN_ERR "%s: length err.\n", __func__);
        goto err;
    }

    /* loop over all pages, map it page individually */
    while (length > 0) {
        pfn = vmalloc_to_pfn(vmalloc_area_ptr);
        ret = remap_pfn_range(vma, start, pfn, PAGE_SIZE, PAGE_SHARED);
        if (ret < 0) {
            printk(KERN_ERR "%s: remap_pfn_range err.\n", __func__);
            goto err;
        }

        start += PAGE_SIZE;
        vmalloc_area_ptr += PAGE_SIZE;
        length -= PAGE_SIZE;
    }

    return 0;

err:
    return ret;
}

/* character device mmap method */
static int mmap_mmap(struct file *filp, struct vm_area_struct *vma)
{
    int ret = 0;

    if (vma->vm_pgoff == 0) {
        /* at offset 0 we map the vmalloc'd area */
        ret =  mmap_vmem(filp, vma);  
    } else if (vma->vm_pgoff == NPAGES) {
        /* at offset NPAGES we map the kmalloc'd area */
        ret = mmap_kmem(filp, vma);
    } else {
        /* at any other offset we return an error */
        ret = -EIO;
    }
    
    return ret;
}

static struct file_operations mmap_fops = {
    .open = mmap_open,
    .release = mmap_release,
    .mmap = mmap_mmap,
    .owner = THIS_MODULE,
};

static int __init my_mmap_init(void)
{
    int ret = 0;
    int i = 0;

    printk(KERN_ERR "%s: start\n", __func__);
    
    /* allocate a memory area with kmalloc. Will be rounded up to a page boundary */
    if ((mmap_dev_info.kmalloc_ptr = kmalloc((NPAGES + 2) * PAGE_SIZE, GFP_KERNEL)) == NULL) {
        ret = -ENOMEM;
        goto out;
    }

    /* round it up to the page bondary，即找到页对齐的地址 */
    mmap_dev_info.kmalloc_area = (int *)PAGE_ALIGN((unsigned long)mmap_dev_info.kmalloc_ptr);

    /* allocate a memory area with vmalloc. */
    if ((mmap_dev_info.vmalloc_area = (int *)vmalloc(NPAGES * PAGE_SIZE)) == NULL) {
        ret = -ENOMEM;
        goto out_kfree;
    }

    /* get the major number of the character device */
    if ((ret = alloc_chrdev_region(&mmap_dev_info.mmap_dev, 0, 1, "mmap")) < 0) {
        printk(KERN_ERR "could not allocate major number for mmap\n");
        goto out_vfree;
    }

    /* initialize the device structure and register the device with the kernel */
    cdev_init(&mmap_dev_info.mmap_cdev, &mmap_fops);
    if ((ret = cdev_add(&mmap_dev_info.mmap_cdev, mmap_dev_info.mmap_dev, 1)) < 0) {
        printk(KERN_ERR "could not allocate chrdev for mmap\n");
        goto out_unalloc_region;
    }

    /* mark the pages reserved，即让申请的memory不被交换到磁盘。*/
    for (i = 0; i < NPAGES * PAGE_SIZE; i += PAGE_SIZE) {
        //mark_page_reserved(vmalloc_to_page((void *)(((unsigned long)(mmap_dev_info.vmalloc_area)) + i)));
        //mark_page_reserved(virt_to_page(((unsigned long)(mmap_dev_info.kmalloc_area)) + i));
        
        SetPageReserved(vmalloc_to_page((void *)(((unsigned long)(mmap_dev_info.vmalloc_area)) + i)));
        SetPageReserved(virt_to_page(((unsigned long)(mmap_dev_info.kmalloc_area)) + i));
    }

    /* store a pattern in the memory - the test application will check for it */
    for (i = 0; i < (NPAGES * PAGE_SIZE / sizeof(int)); i += 2) {
        mmap_dev_info.vmalloc_area[i] = (0xaffe << 16) + i;
        mmap_dev_info.vmalloc_area[i + 1] = (0xbeef << 16) + i;
        mmap_dev_info.kmalloc_area[i] = (0xdead << 16) + i;
        mmap_dev_info.kmalloc_area[i + 1] = (0xbeef << 16) + i;
    }

    /* create class */
    mmap_dev_info.mmap_class = class_create(THIS_MODULE, "mmap_class");
    if (IS_ERR(mmap_dev_info.mmap_class)) {
        printk(KERN_ERR "class_create failed.\n");
        ret = -1;
        goto out_unalloc_region;
    }
    
    /* create device */
    device_create(mmap_dev_info.mmap_class, NULL, mmap_dev_info.mmap_dev, NULL, "mmap_dev");

    printk(KERN_ERR "%s: end\n", __func__);

    return ret;
    
out_unalloc_region:
    unregister_chrdev_region(mmap_dev_info.mmap_dev, 1);

out_vfree:
    vfree(mmap_dev_info.vmalloc_area);
    mmap_dev_info.vmalloc_area = NULL;

out_kfree:
    kfree(mmap_dev_info.kmalloc_ptr);
    mmap_dev_info.kmalloc_ptr = NULL;

out:
    return ret;
}

static void __exit my_mmap_exit(void)
{
    int i = 0;

    /* unregister device */
    device_destroy(mmap_dev_info.mmap_class, mmap_dev_info.mmap_dev);

    /* remove the character deivce */
    cdev_del(&(mmap_dev_info.mmap_cdev));
    
    class_destroy(mmap_dev_info.mmap_class);
    unregister_chrdev_region(mmap_dev_info.mmap_dev, 1);

    /* unreserve the pages */
    for (i = 0; i < NPAGES * PAGE_SIZE; i += PAGE_SIZE) {
        //free_reserved_page(vmalloc_to_page((void *)(((unsigned long)(mmap_dev_info.vmalloc_area)) + i)));
        //free_reserved_page(virt_to_page(((unsigned long)(mmap_dev_info.kmalloc_area)) + i));
        ClearPageReserved(vmalloc_to_page((void *)(((unsigned long)(mmap_dev_info.vmalloc_area)) + i)));
        ClearPageReserved(virt_to_page(((unsigned long)(mmap_dev_info.kmalloc_area)) + i));
        
    }
    
    /* free the memory areas */
    if (mmap_dev_info.vmalloc_area) {
        vfree(mmap_dev_info.vmalloc_area);
        mmap_dev_info.vmalloc_area = NULL;
    }
    
    if (mmap_dev_info.kmalloc_ptr) {
        kfree(mmap_dev_info.kmalloc_ptr);
        mmap_dev_info.kmalloc_ptr = NULL;
    }
}

module_init(my_mmap_init);
module_exit(my_mmap_exit);

MODULE_DESCRIPTION("mmap demo driver");
MODULE_AUTHOR("vector");
MODULE_LICENSE("GPL");

ifneq ($(KERNELRELEASE),)                                                                                                                                                                               
    obj-m := map_driver.o
else
    PWD  := $(shell pwd)
KDIR := /lib/modules/$(shell uname -r)/build

all:
    $(MAKE) -C $(KDIR) M=$(PWD) modules

clean:
    rm -rf .*.cmd *.o *.mod.c *.ko .tmp_versions modules.order Module.symvers
endif

4.2 userspace test app

#include <stdio.h>                                                                                                                                                                                      
#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>

#define LEN (16*4096)

int main(int argc, void **argv)
{
    int i = 0;
    int fd;
    unsigned int *vadr;

    fd = open("/dev/mmap_dev", O_RDWR);
    if (fd < 0) {
        perror("open");
        return -1;
    }

    vadr = mmap(0, LEN, PROT_READ, MAP_SHARED, fd, 0);

    if (vadr == MAP_FAILED) {
        perror("mmap");
        return -1;
    }

    printf("------------------------------------------------");
    for (i = 0; i < (LEN / 4); i++) {
        printf("0x%08x,", *(vadr + i));
        if ((i % 10) == 0)
            printf("\n");
    }

    close(fd);

    return(0);
}

4.3 测试结果

Aiden_SHU
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux内核源码分析之伙伴系统（一）
05-02 2104
目录 一、重要结构体 二、数据结构之间的关系 1、分配数量 2、区域类型 3，备用区域列表 4、区域水位 5、min_free_kbytes 三、分配页面 1、ac参数获取值 2，快速分配 3，慢速分配 一、重要结构体 页 (page) 一个 page 结构表示一个物理内存页面。 区（zone） 因为硬件限制，Linux内核不能把所有的物理内存页统一对待，把属性相同的物理内存页面。归结到了一个区中。 节点 （pglist_data）...
GBASE 8s中的保留页（reserved pages）
因为吃过天津一家超好吃的八珍豆腐从而改名为八珍豆腐的博客
08-22 121
根数据库空间中的前 12 个数据页用于保存系统信息，称为保留页，第一页 记录数据库版权信息，第二页记录数据库配置参数，从第三页开始，每两页为一 对互为备份记录相关信息。下图说明了根数据库空间 12 个保留页的作用，可使用 oncheck -pr 查看根数 据库空间中保留页中保存的信息。page2&page3：记录最后一次检查点的时间和地址，并记录每个逻辑日志的 位置和当前状态。page6&page7：记录数据块（chunk）信息，包括数据块状态、路径、大小、空余大小等。page0：记录版权信息。
Linux内存管理
最新发布
weixin_45673259的博客
06-11 647
Glibc 的 malloc 可以支持多线程，增加了非主分配区（non main arena）支持，主分配区与非主分配区用环形链表进行管理。每一个分配区利用互斥锁（mutex）使线程对于该分配区的访问互斥。每个进程只有一个主分配区，但可能存在多个非主分配区，ptmalloc 根据系统对分配区的争用情况动态增加非主分配区的数量，分配区的数量一旦增加，就不会再减少了。主分配区可以访问进程的 heap 区域和 mmap 映射区域，也就是说主分配区可以使用 sbrk 和 mmap向操作系统申请虚拟内存。
xenomai的API接口
weixin_41602564的博客
04-27 2354
Xenomai: API service tags https://xenomai.org/documentation/xenomai-3/html/xeno3prm/api-tags.html 驱动简介 Xenomai 3 的rtdm驱动更像一般的Linux驱动，named device会在/dev/rtdm/xxx创建一个设备文件。而用户空间使用时，写得来也和Linux的一般char设备相似，...
Linux的内存管理
weixin_56569448的博客
04-29 243
Linux的内存管理
linux内存管理-物理内存管理.pdf
07-24
整个内存管理系统可以分为2部分来看待: 第一部分是对物理内存的管理, 第二部分是对虚拟内存的管理. 物理内存管理的对象是板载的物理内存（DDRAM）, 它把物理内存按页划分, 并把这些页放到一个池子里面. 物理内存管理...
Linux内核内存管理技术分享
08-27
MMU（Memory Management Unit）是Linux内存管理的核心组件，负责将虚拟地址转换为物理地址。Cache是高速缓存，用于加速数据的访问。 Linux虚拟地址空间布局是指Linux操作系统中进程的虚拟地址空间的组织方式。 ...
linux内存管理-FAQs.pdf
07-24
与内存管理系统相关的各种flags汇总如下:  每个物理page有自己的flags, 定义在struct page -> unsigned long flags; 详情见2.2.2节的《page》  每个内存块（多个page组成一个内存块）有自己的pageblock_flags, ...
Linux_mem.rar_Linux内核源代码解读--内存管理
09-23
在Linux操作系统中，内存管理是内核的核心组成部分之一，它负责高效、安全地分配和管理系统的内存资源。本文将深入探讨Linux内核源代码中的内存管理机制，主要基于"Linux_mem.rar"压缩包中的"Linux物理内存管理.pdf...
linux 内存管理机制详细解析
09-15
合理规划和配置Linux内存使用是提升系统性能和稳定性的关键。包括设置合适的交换空间大小，以及关注内存使用率和效率。通过监控工具及时发现和处理内存问题，可以避免系统异常，确保服务的持续稳定运行。
Linux内存管理--基本概念
sinat_32152141的博客
10-11 510
每个进程有它自己的PGD( Page Global Directory)，它是一个物理页，并包含一个pgd_t数组。其定义见。进程的pgd_t数据见 task_struct -> mm_struct -> pgd_t * pgd;为了存储保护位，pgprot_t被定义，它拥有相关的flags并经常被存储在page table entry低位(lower bits)，其具体的存储方式依赖于CPU架构。每个pte_t指向一个物理页的地址，并且所有的地址都是页对齐的。
linux内核之内存管理图解
weixin_34064653的博客
06-16 641
2019独角兽企业重金招聘Python工程师标准>>> ...
Linux内存管理详情
guhong1995的博客
02-21 331
本文介绍了物理地址、逻辑地址、线性地址三种地址的概念，介绍了Linux的实模式和保护模式的区别。最后重点介绍Linux系统的虚拟内存管理机制--分段机制和分页机制。并在最后以程序访问虚拟内存中数据的流程的形式总结内存管理。
一文讲解,Linux内核——内存管理（建议收藏）
m0_74282605的博客
11-18 1560
程序不需要全部装入即可运行，运行的时候根据需要动态调入数据，若内存不够，还需要换出一些数据。特征：（1）多次性：无需在作业运行时一次全部装入内存，而是允许被分成多次调入内存的。​ （2）对换性：无需在作业运行时一直常驻内存，而是允许在作业运行的过程中，将作业换入，换出。​ （3）虚拟性：从逻辑上扩充了内存的容量，使用用户看到的内存容量，远大于实际的容量。
Linux内存管理(一)：内存管理概述
baidu_38797690的博客
03-03 2372
Linux系统的内存管理基本概念，介绍了虚拟内存、物理内存、逻辑地址、物理地址之间的关系，简单介绍了Linux最基本的虚拟内存管理机制——页式管理机制，简要描述了进程虚拟空间的划分方式和各区域的作用。
万字长文，别再说你不懂Linux内存管理了，30 张图给你安排的明明白白
程序IT圈
06-04 1087
之前写了两篇详细分析 Linux 内存管理的文章，读者好评如潮。但由于是分开两篇来写，而这两篇内容其实是有很强关联的，有读者反馈没有看到另一篇读起来不够不连贯，为方便阅读这次特意把两篇整...
linux page结构定义,linux 的 page 结构体的一点笔记
weixin_39626298的博客
05-14 513
Linux的内核在内存管理中处理的最小单位是physical pages然而处理器的的最小的可寻址的单位是byte 或者是 word很多32位系统构架都是4k的页，64位则是8k的页所以对于4k的页，1G的内存就有262144个不同的页内核通过struct page 结构体来表示每一个页，定义在中程序代码： /** Each physical page in the system has a st...
Linux中的内存分配和释放之__free_pages()函数分析
satanwxd的专栏
03-07 9230
  记得我们在上篇文章mem_init()分析中提到__free_page()函数吗？我们现在来完善它。它的调用过程是这样的：mem_init()->free_all_bootmem_node():我们知道这个函数是统计一共释放了多少空闲页。->free_all_bootmem_core()就是在这个函数里面先后多次调用__free_pages()函数。目的就是为了释放每个内存node里面无用的内
深入解析Linux虚拟内存管理
"《理解Linux虚拟内存管理》是 Bruce Perens 的开源系列书籍之一，由 Mel Gorman 编著，详细介绍了Linux内核中的虚拟内存管理系统。这本书被认为是该领域的权威著作，阅读时需要配合查看源代码以深入理解。" 《理解...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值