内存资源管控
实现空间内存的最大化利用。

映射机制

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

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");