【1117】【内存资源管控】【笔记】

内存资源管控

实现空间内存的最大化利用。

映射机制

需要关注的问题包括:性能是否受到影响,以及易用性如何。

MMU:有个号码把虚拟空间和物理空间集训对应

静态映射:板子启动后:就已经初始化好

动态映射:手动映射区域


进程A的数据传给进程B

在应用层直接使用共享空间


摄像头快速拷贝:

两个进程指向同一文件

内存管理单元MMU

bash 复制代码
内存管理单元 //通过MMU中页表,把物理内存 映射到 虚拟内存 
           //安全(隔离,不能直接访问,加检测,启动MMU后,就不能直接访问硬件地址了)
           //易用(多进程时,独立进程只管自己独立虚拟内存,不管实际存储位置)
映射要解决两个问题 //映射的最小单位(粒度)和映射的规则。	
映射的最小单位 //MMU中VA到PA映射的最小单位称为页(Page)=4k
映射的规则  //页表:虚存页码(va页号) + 物存页码(pa页号)
	//VA的一页:  0x30004000~0x30004fff   映射到  PA的一页0x00008000~0x00008fff
	//     CPU 访问  0x30004008  就是 访问  0x00008008,  
        //页内偏移不变(必须页整体映射,不能把页拆分,分别映射到不同位置),一一映射
        //多级页表本质是当页表大时,如何快速搜索   

MMU设置 //就是CPU arm 核里 MMU专用寄存器的设置,

应用空间 //0~3G
内核空间 //3G~4G
      //直接映射(连续): 896M的虚拟地址与物理地址的前896M进行直接映射
      //高端内存(不连续 vmalloc):128M 临时映射,用完释放,循环使用 -> 访问所有物理内存 
      //内核空间被多个进程共用

使用MMU进行隔离;就不能直接访问物理地址;

可以加一些安全检测机制;


不同权限;安全隔离


易用性:不用关心真实地址;直接使用虚拟地址


映射机制:

  • 映射最小单位:页(4K)

静态映射:一一对应

动态映射:vmalloc


映射关系:

内存空间 统一编址 ,端口空间 独立编址

不同的dev的空间如何去访问?

如何统一起来??内存、网卡、falsh

访问dev时,做一个编号访问;每个设备里也有不同的地址


统一编址:

把所有空间都看作内存的扩展;

独立编址:

与内存有相同的地址范围;所以使用特殊的指令


先申请区域:

共享内存

bash 复制代码
共享内存 //多进程映射到同一物理内存 -> 进程间通讯,减少拷贝(最快)
场景 //高并发,数据量大,效率要求高时。

验证测试:
$ gcc server_mm.c -o server
$ gcc client_mm.c -o client
$ ./server  /*

如果报错文件已存在,需删除shmid,或 改一下(key_t)1006的值
$ ipcs -m 查看共享内存段
------------ 共享内存段 --------------
键        shmid      拥有者  权限     字节     连接数  状态
0x56050753 16         yhai       666        4096       0
0x000003ec 17         yhai       666        4096       0
$ ipcrm --m 17  删除指定id的共享内存段

*/
$ ./client
bash 复制代码
# 客户端

//client_mm.c
#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<unistd.h>
#include<sys/shm.h>
int main()
{
	//申请共享内存(key值,大小,权限等标志)
	int shm=shmget((key_t)1006,4096,IPC_CREAT);
	if(shm<0){
		perror("shmget");
		return 2;
	}

	//关联共享内存(映射共享内存到进程数据段)
	char* mem=shmat(shm,NULL,0);
	int i=0;
	while(1)
	{
		//写共享内存
		mem[i]='a'+i;
		i++;
		mem[i]='\0';
		sleep(1);
	}

	shmdt(mem);//取消关联(分离 共享内存和进程)
	return 0;
}
bash 复制代码
# 服务端

//server_mm.c
#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<unistd.h>
#include<sys/shm.h>

int main()
{
	//申请共享内存(key值,大小,权限等标志)
	int shm=shmget((key_t)1006,4096,IPC_CREAT|IPC_EXCL|0666);//默认权限
	if(shm<0)
	{
	  perror("shmget");
	  return 2;
	}
	printf("%d\n",shm);

	//映射共享内存到进程数据段
	char* mem=(char*)shmat(shm,NULL,0);
	while(1)
	{
	  //读取共享内存
	  printf("server receive:%s\n",mem);
	  sleep(1);
	}

	sleep(2);
	shmdt(mem); //分离 共享内存和进程
	shmctl(shm,IPC_RMID,NULL);//删除共享内存
	return 0;
}

文件内存映射

bash 复制代码
mmap 内存映射 //把文件内容映射到进程的虚拟内存 -> 避免read,write的用户空间到内核空间拷贝
       //映射后,进程就可以采用指针的方式读写这一段内存,
       //对磁盘上的文件,系统会自动回写同步
       //Linux 一切皆文件,如 /dev/video0
场景 //频繁读取驱动数据时(如视频采集)

把外存上的文件直接映射到应用层

可以是普通文件、也可以是设备文件

把文件映射到进程里面

最简

bash 复制代码
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
 
int main(void)
{
int fd;
void *result;
fd = open("test", O_RDWR);
if (-1 == fd){
	return -1;
}

//映射文件到内存
result = mmap(0, \   //指定映射的起始地址, 通常设为NULL, 由系统指定
	1024, \  //映射到内存的文件长度
	PROT_READ|PROT_WRITE, \ //映射区的保护方式, PROT_EXEC: 映射区可被执行 PROT_READ: 可读  PROT_WRITE: 可写
	MAP_SHARED, \ //MAP_SHARED:写入映射区的数据会复制回文件, 且允许其他映射该文件的进程共享。
               //MAP_PRIVATE:对映射区的写入操作会产生一个映射区的复制(copy-on-write), 对此区域所做的修改不会写回原文件
	fd, \  //由open返回的文件描述符, 代表要映射的文件
	0);    //以文件开始处的偏移量, 必须是分页大小的整数倍, 通常为0, 表示从文件头开始映射
if (result<0) {
	printf("mmap failed: %s\n", strerror(errno));
	return -1;
}

close(fd);//关闭fd,不影响映射内容的修改

strncpy(result, "5", 1);  //像buffer一样操作

munmap(0, 1024);  //取消映射

return 0;
}

//测试:
装备一个test文件 //注意文件不能为空,否则异常退出
$ gcc app.c
$ ./a.out
$ cat test   //发现文件第一个字符成功改为 5

比直接使用read快很多

两次拷贝:

驱动映射

bash 复制代码
//验证测试
$ aarch64-linux-gnu-gcc app.c
$ make
$ cp a.out  driver.ko /nfs/rootfs
重启板子

# insmod driver.ko
# mknod /dev/led c 500 0
# ./a.out //看到一致信息表示成功

//app.c
#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <string.h>

int main( void )
{
	int fd;
	char *buffer;
	char *mapBuf;
	fd = open("/dev/led", O_RDWR);//打开设备文件,内核就能获取设备文件的索引节点,填充inode结构
	if(fd<0){
		printf("open error,fd = %d\n",fd);
		return -1;
	}
	buffer = (char *)malloc(1024);
	memset(buffer, 0, 1024);
	mapBuf = mmap(NULL, 1024, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);//内存映射,会调用驱动的mmap函数
	strcpy(mapBuf, "test data for mmap");//向映射段写数据
	memset(buffer, 0, 1024);   //清空,避免误判
	strcpy(buffer, mapBuf);    //从映射段读取数据
	printf("read data is %s\n", buffer);//如果读与写一致,说明映射成功

	munmap(mapBuf, 1024);//解除映射
	free(buffer);
	
	close(fd);
	return 0;
}	

//driver.c
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>	  
#include <linux/cdev.h>  
#include <linux/types.h> //定义dev_t类型
#include <linux/slab.h> //定义kmalloc接口
#include <asm/io.h>//定义virt_to_phys接口
#include <linux/mm.h>//remap_pfn_range
#define MM_SIZE 4096

#define LED_MA 500  //主设备号 用于区分不同种类的设备
#define LED_MI 0    //次设备号 用于区分同一类型的多个设备
#define LED_NUM 1 


struct cdev cdev; //定义字符设备

static int  led_open(struct inode *inode, struct file *file)
{
	printk("driver led  open\n");
	return 0;
}

static int  led_release(struct inode *inode, struct file *file)
{
	printk("driver led  close\n");
	return 0;
}

char *buf = NULL;
static int device_mmap(struct file *file, struct vm_area_struct *vma)
{
  vma->vm_flags |= VM_IO;//表示对设备IO空间的映射
  vma->vm_flags |= (VM_DONTEXPAND | VM_DONTDUMP);//标志该内存区不能被换出,在设备驱动中虚拟页和物理页的关系应该是长期的,应该保留起来,不能随便被别的虚拟页换出

   if(remap_pfn_range(vma,//虚拟内存区域,即设备地址将要映射到这里
	   vma->vm_start,//虚拟空间的起始地址
            virt_to_phys(buf)>>PAGE_SHIFT,//与物理内存对应的页帧号,物理地址右移12位
            vma->vm_end - vma->vm_start,//映射区域大小,一般是页大小的整数倍
          vma->vm_page_prot))//保护属性,
   {
	return -EAGAIN;
   }
    return 0;
}
struct file_operations  led_fops = { 
	.owner = THIS_MODULE,
	.open =  led_open,
	.release =  led_release,
	.mmap = device_mmap,
};

static int led_init(void)
{
	dev_t devno = MKDEV(LED_MA, LED_MI);
	int ret;

	ret = register_chrdev_region(devno, LED_NUM, "yhai_led");  
	if (ret < 0) { 
		printk("register_chrdev_region\n");
		return ret;
	}

	cdev_init(&cdev, & led_fops);
	ret = cdev_add(&cdev, devno, LED_NUM); 
	if (ret < 0) {
		printk("cdev_add\n");
		return ret;
	}

	printk("led init 2\n");

	buf = (char *)kmalloc(MM_SIZE, GFP_KERNEL);//内核申请内存只能按页申请,申请该内存以便后面把它当作虚拟设备
	return 0;
}

static void led_exit(void)
{
	dev_t devno = MKDEV(LED_MA, LED_MI);
	kfree(buf);  //卸载申请的内存空间
	cdev_del(&cdev);  
	unregister_chrdev_region(devno, LED_NUM);  
	printk("led exit\n");
}

module_init(led_init); 
module_exit(led_exit); 
MODULE_LICENSE("GPL"); 

内存拷贝两次:

把两个buf指向同一个物理区域

应用,内核,物理空间 隔离和转换

bash 复制代码
在mmu基础上,隔离
	
应用陷入内核 //系统调用(swi软中断)
             //硬件中断
             //异常(abort undefined)

进程从用户栈切换到内核栈  

目的:

  • 安全
  • 易用

内存分配

内存分配算法

堆:向上增涨

内存分配:malloc、new;

频繁分配:内存碎片

内存不连续了;需要创建额外链表


如何尽量不产生碎片

伙伴算法

偶数页可以直接申请

奇数页:可以进行组合

申请的时候Z:尽量2的N次方的大小

释放:释放的时候会把周围的空间一起合并,放到对应大小位置

速度还是比较慢

针对外部碎片


针对申请空间比较小;按页分配比较浪费

内部碎片:

一页4K;不到一页

把页再进行分配:

先申请"不满的",再申请"空的";如果都"满了"就再申请一个"cache"


申请的时候:设定一个缓存cache列表;不会立马还回内存

平繁申请的时候不还回;里的数据也不清楚

内存分配函数

示例代码

bash 复制代码
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h> //for kmalloc
#include <linux/gfp.h>
#include <linux/vmalloc.h>

struct gpio_dev{
	int led_gpio;
	int sensor_gpio;
};

static struct gpio_dev *gpio_dev = NULL;

struct gpio_dev *dev_array;

int *pages;

char *big;
static int led_init(void)
{
	gpio_dev = kmalloc(sizeof(struct gpio_dev), GFP_KERNEL); /* 申请空间<128k时
		GFP_KERNEL(可睡眠), 
		GFP_ATOMIC(不睡眠,用于中断)
		GFP_DMA(用于DMA时),  
		GFP_DMA|GFP_ATOMIC  可组合
	*/
	if (gpio_dev == NULL) {
		printk(KERN_ERR"kmalloc struct gpio_dev err \n");
		return -ENOMEM;
	}
	memset(gpio_dev, 0, sizeof(struct gpio_dev));	
	gpio_dev->led_gpio=2;


	//gpio_dev = kzalloc(sizeof(struct gpio_dev), GFP_KERNEL); 添加清零
	//devm_kzalloc(&pdev->dev, sizeof(struct gpio_dev), GFP_KERNEL);   系统自动释放

	dev_array = kcalloc(3, sizeof(struct gpio_dev), GFP_KERNEL);
	if (!dev_array){
		printk(" kcalloc fail\n");
		return -1;
	}
	dev_array[0].led_gpio=6;


	pages = (int *)__get_free_pages(GFP_KERNEL, 3);
	if (!pages){
		printk(" __get_free_pages fail\n");
		return -1;
	}
	*pages =9;

	big = vmalloc(1024 * 1024 * 8); /*申请8M空间
	用 # free  可查看卸载前后内存变化  used的变化

	*/
	if (!big){
	return -ENOMEM;
	}

	printk(" led init go 2\n");
	return 0;
}

static void led_exit(void)
{
	printk(" data =%d \n",gpio_dev->led_gpio);
	printk(" dev_array  =%d \n",dev_array[0].led_gpio);
	printk(" pages  =%d \n",*pages);
	//释放空间
	kfree(gpio_dev);
	kfree(dev_array);
	free_pages(pages,3);
	vfree(big);
	printk("led exit \n");
}

module_init(led_init); 
module_exit(led_exit); 
MODULE_LICENSE("GPL"); 
相关推荐
AI导出鸭PC端38 分钟前
用 AI 导出鸭高效处理:豆包导 pdf 怎么压缩但清晰
android·人工智能·pdf·豆包·ai导出鸭
therese_100862 小时前
流媒体协议RTMP推流demo-安卓端
android
疯华整猫2 小时前
同一个 App,五种手机五种死法:2026 年 Android 五大 ROM 兼容的 8 个真实坑
android·性能优化
qingwufeiyang_5302 小时前
Docker学习笔记2
笔记·学习
疯华整猫2 小时前
别再抄 Flutter 了:2026 年 Android / iOS / 小程序跨端架构选型的四本成本账
android·前端·ios
传奇开心果编程3 小时前
【Flutter踩坑排雷】第30课:异常未捕获坑|未捕获异常直接闪退,全局兜底故障处理
android·flutter·ios·移动开发·dart·ui框架·声明式ui
Z21-X3 小时前
云原生运维学习笔记:从操作系统底层到 Kubernetes 集群的深度实践
运维·笔记·学习·云原生·kubernetes
星恒随风3 小时前
MySQL 从零入门(七):索引原理与 B+ 树详解——从磁盘 I/O 到 InnoDB 聚簇索引
linux·服务器·数据库·笔记·mysql
恋猫de小郭4 小时前
Flutter Native Interop 稳定了,Platform Channel 要退场了
android·前端·flutter