Linux - 内存管理

最新推荐文章于 2024-07-25 13:33:06 发布
最新推荐文章于 2024-07-25 13:33:06 发布
阅读量558 收藏 11
点赞数 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 测试结果

Andre-S
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux内存管理 -- Slab
badbayyj的博客
06-29 2905
碎片即一个完整的东西被打碎，零散的分布着。这就像内存，如果不加以管理，就会有很多未被使用的碎片，造成内存的浪费。 在linux中，内存是以页（page）来管理的，一page一般为4KB，而外部/内部碎片就是以page为界线划分的。内部碎片就是指被内核分配出去但是不能被利用的内存，而外部碎片是指由于频繁地申请和释放页框而导致的某些小的连续页框，比方只有一个页框，无法分配给需要大的连续页框的进程而导致的内存碎片。如一个page的前后都被分配了出去，没有其他page与之相连，这个page就成了外部碎片。这时候bu
linux---内存管理
badman_lee的博客
02-13 2474
即使是现代操作系统中，内存依然是计算机中很宝贵的资源，看看你电脑几个T固态硬盘，再看看内存大小就知道了。为了充分利用和管理系统内存资源，Linux采用虚拟内存管理技术，利用虚拟内存技术让每个进程都有4GB互不干涉的虚拟地址空间。进程初始化分配和操作的都是基于这个「虚拟地址」，只有当进程需要实际访问内存资源的时候才会建立虚拟地址和物理地址的映射，调入物理内存页。
Linux - 内存性能评估
热门推荐
小工匠
03-06 2万+
内存的管理和优化是系统性能优化的一个重要部分，内存资源的充足与否直接影响应用系统的使用性能。在进行内存优化之前，一定要熟悉Linux的内存管理机制，这里我们重点探讨如何通过系统命令监控Linux系统的内存使用状况。
Linux内存管理
weixin_45673259的博客
06-11 654
Glibc 的 malloc 可以支持多线程，增加了非主分配区（non main arena）支持，主分配区与非主分配区用环形链表进行管理。每一个分配区利用互斥锁（mutex）使线程对于该分配区的访问互斥。每个进程只有一个主分配区，但可能存在多个非主分配区，ptmalloc 根据系统对分配区的争用情况动态增加非主分配区的数量，分配区的数量一旦增加，就不会再减少了。主分配区可以访问进程的 heap 区域和 mmap 映射区域，也就是说主分配区可以使用 sbrk 和 mmap向操作系统申请虚拟内存。
概述 - Linux内存管理（一）
生活需要深度
04-10 6469
内存管理是从单板上电运行uboot启动引导linux并完成文件系统挂载（文件系统管理Nandflash）过程前两个环节都需要完成的重要工作，并且随着程序推进的内存管理也逐渐完善起来。如果一步到位直接编写一个非常完整的内存管理系统，这个过程是相当麻烦且低效的。u-boot做为启动引导程序，其核心功能就是引导内核镜像，所以其内存管理功能并不用像Linux内核中的内存管理一样功能齐全。u-boot中没有内存分配、回收、缓存等功能，内存管理其实只做一件事：虚实地址映射，而且是固定映射。linux内核中的内存管理支.
深入理解Linux内核-内存管理
weixin_44332365的博客
05-09 1378
深入理解Linux学习分享
linux性能优化-内存原理
张幺幺的博客——学习记录
02-08 3133
linux性能优化-内存原理
linux内存管理
wwwlyj123321的博客
12-08 3424
对于物理内存内存，linux对内存的组织逻辑从上到下依次是：node，zone，page，这些page是根据buddy分配算法组织的，看下面两张图：
Linux-系统管理
记录所思、所学、所感，分享每一份收获。
03-17 4574
本章主要讲解linux系统管理的基础篇，分为进程管理、工作管理、资源查看、定时任务四个小节，其中会介绍经常用到的一些命令及其使用技巧。
Linux--JVM内存设置
m0_67393157的博客
08-29 4266
对于jvm的设置我一直知道的很少，有时候遇到outOfMemoryError只会一个简单的设置“-Xms256m -Xmx512m”。有几个问题一直没搞明白：1、jvm的内存大小究竟应该设置成多少最合适？2、jvm的默认大小是多少？3、jvm参数有哪些？哪些参数都表示什么意思？现在的服务器配置一般都是十几个CPU、十几个内存，如何设置才最合适？在网上搜索了一下：对于问题1：jvm堆不是越大越好的，一般最大设置到1G-1.5G就完全足够了，如果总是出现内存溢出，一般是应用有问题了。...
操作系统-linux-内存-缓存
11-24 3919
目录 Buffer I/O 和 Direct I/O 文件占用内存详解 缓存相关参数优化 Buffer I/O 和 Direct I/O 文件占用内存详解 缓存相关参数优化
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相关指令
最新发布
m0_46502962的博客
07-25 145
其中的-lpthread不是必须的，只有用到该库才输入加上。//该指令将demo.c生成的a.out文件命名为demo8。//将运行结果放到test.ret.txt文件中，没有就创建。1.查看手册 man 3 free。将该运行程序放到后台运行。③(gbd)r 运行。④(gbd)q 退出。
Linux：Linux发展史
weixin_51142926的博客
07-22 4270
大家好！此篇文章并非技术博文，而是简单了解Linux的时代背景和发展史，只有知其所以然才能让我们更好地让走进Liunx的世界！
Linux Vim教程：多文件编辑与窗口管理
07-25 874
Vim作为一款功能强大的文本编辑器，支持多文件编辑和窗口管理。掌握这些高级技巧可以大大提高工作效率和文件处理能力。本文将详细介绍Vim中多文件编辑与窗口管理的各种方法和技巧，包括缓冲区、标签页、分屏、快速切换等。通过这些实用技巧，您可以更高效地在Vim中进行复杂的文本编辑任务。
深入解析Linux虚拟内存管理
"《理解Linux虚拟内存管理》是 Bruce Perens 的开源系列书籍之一，由 Mel Gorman 编著，详细介绍了Linux内核中的虚拟内存管理系统。这本书被认为是该领域的权威著作，阅读时需要配合查看源代码以深入理解。" 《理解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值