linux 内存映射2 内核/用户进程间通信

1、register_chrdev() 函数注册字符设备：

if (register_chrdev(MAJOR_NUM, " gobalvar ", &gobalvar_fops)) 　{ 　　//…注册失败 　} 　else 　{ 　　//…注册成功 　}

　　其中，register_chrdev函数中的参数MAJOR_NUM为主设备号,"gobalvar"为设备名，gobalvar_fops为包含基本函数入口点的结构体，类型为file_operations。当gobalvar模块被加载时，gobalvar_init被执行，它将调用内核函数 register_chrdev，把驱动程序的基本入口点指针存放在内核的字符设备地址表中，在用户进程对该设备执行系统调用时提供入口地址。

2、virt_to_phys、ioremap被定义为一个Marco，其原型为__ioremap，所以在编译时要加选项 -O1(或-O2).

3、int remap_page_range(unsigned long from, unsigned long phys_addr, unsigned long size,

pgprot_t prot)

其中from是映射开始的虚拟地址。这个函数为虚拟地址空间from和from+size之间的范围构栽 页表；

phys_addr是虚拟地址应该映射到的物理地址；size是被映射区域的大小；prot是保护标志

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/wrapper.h> /* for mem_map_(un)reserve */
#include <asm/io.h> /* for virt_to_phys */
#include <linux/slab.h> /* for kmalloc and kfree */

//宏MODULE_PARM(var,type) 用于向模块传递命令行参数。
//var为接受参数值的变量名，type为采取如下格式的字符串[min[-max]]{b,h,i,l,s}。
//min及max 用于表示当参数为数组类型时，允许输入的数组元素的个数范围；
//b：byte；h：short；i：int；l：long；s：string。
//如果为MODULE_PARM(myintArray, "4i"),那么表示数组的最大长度为4

MODULE_PARM(mem_start, "i");
MODULE_PARM(mem_size, "i");

static int mem_start = 201, mem_size = 10;
static char *reserve_virt_addr;
static int major;

int mmapdrv_open(struct inode *inode, struct file *file);
int mmapdrv_release(struct inode *inode, struct file *file);
int mmapdrv_mmap(struct file *file, struct vm_area_struct *vma);
int mmapdrv_close(struct inode *inode, struct file *file);
/*
* NOTE:
* read, write, poll, fsync, readv, writev can be called
* without the big kernel lock held in all filesystems.
*/
//struct file_operations {
// struct module *owner;
// loff_t (*llseek) (struct file *, loff_t, int);
// ssize_t (*read) (struct file *, char *, size_t, loff_t *);
// ssize_t (*write) (struct file *, const char *, size_t, loff_t *);
// int (*readdir) (struct file *, void *, filldir_t);
// unsigned int (*poll) (struct file *, struct poll_table_struct *);
// int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
// int (*mmap) (struct file *, struct vm_area_struct *);
// int (*open) (struct inode *, struct file *);
// int (*flush) (struct file *);
// int (*release) (struct inode *, struct file *);
// int (*fsync) (struct file *, struct dentry *, int datasync);
// int (*fasync) (int, struct file *, int);
// int (*lock) (struct file *, int, struct file_lock *);
// ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *);
// ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);
// ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
// unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
//};

static struct file_operations mmapdrv_fops = { owner: THIS_MODULE,
mmap: mmapdrv_mmap, open: mmapdrv_open,// close: mmapdrv_close,
release: mmapdrv_release
};

int init_module(void) {
if ((major = register_chrdev(0, "mmapXuangdrv", &mmapdrv_fops)) < 0) {
printk("mmapdrv: unable to register character device/n");
return ( -EIO);
}

printk("mmap device major = %d/n", major);

printk("high memory physical address 0x%ldM/n", virt_to_phys(high_memory)
/1024/ 1024);

reserve_virt_addr = ioremap(mem_start *1024* 1024, mem_size*1024* 1024 );

if (reserve_virt_addr) {
int i;
printk("reserve_virt_addr = 0x%lx/n", (unsigned long)reserve_virt_addr);
for (i = 0; i < mem_size *1024* 1024; i += 4) {
reserve_virt_addr[i] = 'a';
reserve_virt_addr[i + 1] = 'b';
reserve_virt_addr[i + 2] = 'c';
reserve_virt_addr[i + 3] = 'd';
}
} else {
printk("reserve_virt_addr = 0x%lx;so return -ENODEV;/n", (unsigned long)reserve_virt_addr);
unregister_chrdev(major, "mmapXuangdrv");
return -ENODEV;
}
return 0;
}

/* remove the module */
void cleanup_module(void) {
if (reserve_virt_addr)
iounmap(reserve_virt_addr);

unregister_chrdev(major, "mmapXuangdrv");
return;
}

int mmapdrv_open(struct inode *inode, struct file *file) {
MOD_INC_USE_COUNT;
return (0);
}
int mmapdrv_close(struct inode *inode, struct file *file) {
MOD_DEC_USE_COUNT;
return (0);
}

int mmapdrv_release(struct inode *inode, struct file *file) {
MOD_DEC_USE_COUNT;
return (0);
}

int mmapdrv_mmap(struct file *file, struct vm_area_struct *vma) {
unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
unsigned long size = vma->vm_end - vma->vm_start;

if (size > mem_size *1024* 1024) {
printk("size too big/n");
return ( -ENXIO);
}

offset = offset + mem_start * 1024* 1024;

/* we do not want to have this area swapped out, lock it */
vma->vm_flags |= VM_LOCKED;
//if (remap_page_range(vma, vma->vm_start, offset, size, PAGE_SHARED)) {
if (remap_page_range(vma->vm_start, offset, size, PAGE_SHARED)) {
printk("remap page range failed/n");
return -ENXIO;
}
printk("First char is: = %c/n", *((char *)vma->vm_start));
return (0);
}

在系统能够启动的时候自动的做了预留空间，并且在用户使用mmap时可以映射到用户空间