当前位置：文江博客话题详情

kmalloc申请的内存映射到用户态的问题

发布于 2022-09-30 11:44:30 字数 23115 浏览 38 评论 0

我最近写一个内存映射的模块，上网查了些资料，自己也写了测试程序，可是映射出现问题：

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/kthread.h>
#include <asm/uaccess.h>
#include <linux/proc_fs.h>
#include <linux/err.h>
#include <linux/mm.h>
#include <asm/page.h>
MODULE_AUTHOR("cwj@126.com");
MODULE_DESCRIPTION("KENEL_MAP.DEMO");
MODULE_LICENSE("GPL");
#define MEM_SHARE_DIR "mem_share_dir"
#define MEM_SHARE_ADDR "mem_share_addr"
#define MEM_SHARE_SIZE "mem_share_size"
#define MEM_SIZE 100
#define PARM_SIZE 32
unsigned long addr;
char addr_py[PARM_SIZE];
char size_py[PARM_SIZE];
unsigned long addr_cnt_len;
int i;
static struct task_struct *thread_map;
static struct proc_dir_entry *mem_share_dir;
static struct proc_dir_entry *mem_share_addr;
static struct proc_dir_entry *mem_share_size;
static unsigned char *p1, *p2, *p3;
long atol(const char *str)
{
unsigned int index;
unsigned int num;
int ret;
ret = 0;
index = 1;
num = 0;
//计算字符串的长度(strlen的实现，字符串中只包含数字字符)
while(*str)
{
if(*str < '0' || *str > '9') //判断字符是否是数字
{
return -1;
}
str++;
num++;
}
//转换字符到相应的数字，这里最好的数据结构描述应该是栈
while(str--, num--)
{
ret += index * (*str - '0');
index *= 10;
}
return ret;
}
static int proc_read_addr(char *page, char **start, off_t off, int count, int *eof, void *data)
{
int ret;
ret = 0;
if(off > 0)
{
printk("copy has finished !\n");
return ret;
}
if(addr == 0)
{
return ret;
}
sprintf(page, "%lu", addr);
printk("page =%s, addr = %lu\n", page, addr);
ret = PARM_SIZE;
return ret;
}
static int proc_write_addr(struct file *fp, const char *buf, unsigned long count, void *data)
{
int ret;
memset(addr_py, 0, PARM_SIZE);
ret = count;
if(count > PARM_SIZE && count == 0)
{
printk("buf fault!\n");
return 0;
}
if(copy_from_user(addr_py, buf, count))
{
printk("copy_from_user fault!\n");
return -1;
}
return ret;
}
static int proc_read_size(char *page, char **start, off_t off, int count, int *eof, void *data)
{
int ret;
ret = 0;
if(off > 0)
{
printk("copy has finished !\n");
return ret;
}
if(addr_cnt_len == 0)
{
return 0;
}
sprintf(page, "%lu", addr_cnt_len);
ret = PARM_SIZE;
return ret;
}
static int proc_write_size(struct file *fp, const char *buf, unsigned long count, void *data)
{
int ret;
memset(size_py, 0, PARM_SIZE);
ret = count;
if(count > PARM_SIZE && count == 0)
{
printk("buf fault!\n");
return 0;
}
if(copy_from_user(size_py, buf, count))
{
printk("copy_from_user fault!\n");
return -1;
}
addr_cnt_len = atol(size_py);
return ret;
}
static int thread_map_func(void *data)
{
if(kthread_should_stop())
return 0;
while(p1 || p2 || p3)
{
set_current_state(TASK_UNINTERRUPTIBLE);
if(kthread_should_stop())
break;
if(i == 3 && addr_cnt_len == 0)
{
break;
}
if(addr_cnt_len != 0)
goto __next;
if(p1 && i == 0)
{
SetPageReserved(virt_to_page(p1));
addr = __pa(p1);
addr_cnt_len = 27;
i++;
}
else if(p2 && i == 1)
{
SetPageReserved(virt_to_page(p2));
addr = __pa(p2);
addr_cnt_len = 27;
i++;
}
else if(p3 && i == 2)
{
SetPageReserved(virt_to_page(p3));
addr = __pa(p3);
addr_cnt_len = 27;
i++;
}
printk("py = %lu\n", addr);
__next:
schedule_timeout(50 * HZ);
}
return 0;
}
static int __init init_kernel_map(void)
{
thread_map = NULL;
mem_share_dir = NULL;
mem_share_addr = NULL;
mem_share_size = NULL;
mem_share_dir = proc_mkdir(MEM_SHARE_DIR, NULL);
if(mem_share_dir == NULL)
{
printk("proc create fault!\n");
return 0;
}
mem_share_addr = create_proc_entry(MEM_SHARE_ADDR, 0644, mem_share_dir);
if(mem_share_addr == NULL)
{
remove_proc_entry(MEM_SHARE_DIR, NULL);
printk("mem_share_addr fault!\n");
return 0;
}
mem_share_addr->read_proc = proc_read_addr;
mem_share_addr->write_proc = proc_write_addr;
mem_share_addr->uid = 0;
mem_share_addr->gid = 0;
mem_share_size = create_proc_entry(MEM_SHARE_SIZE, 0644, mem_share_dir);
if(mem_share_size == NULL)
{
remove_proc_entry(MEM_SHARE_ADDR, mem_share_dir);
remove_proc_entry(MEM_SHARE_DIR, NULL);
printk("mem_share_size fault!\n");
return 0;
}
mem_share_size->read_proc = proc_read_size;
mem_share_size->write_proc = proc_write_size;
mem_share_size->uid = 0;
mem_share_size->gid = 0;
thread_map = kthread_create(thread_map_func, NULL, "kernel_mem_share");
if(IS_ERR(thread_map))
{
printk("thread create fault!\n");
return 0;
}
p1 = kmalloc(MEM_SIZE, GFP_KERNEL);
p2 = kmalloc(MEM_SIZE, GFP_KERNEL);
p3 = kmalloc(MEM_SIZE, GFP_KERNEL);
memset(p1, 0, MEM_SIZE);
memset(p2, 0, MEM_SIZE);
memset(p3, 0, MEM_SIZE);
memcpy(p1, "111111111111111111111111111", 27);
memcpy(p2, "222222222222222222222222222", 27);
memcpy(p3, "333333333333333333333333333", 27);
wake_up_process(thread_map);
return 0;
}
static void __exit exit_kernel_map(void)
{
if(p1)
{
ClearPageReserved(virt_to_page(p1));
kfree(p1);
p1 = NULL;
}
if(p2)
{
ClearPageReserved(virt_to_page(p2));
kfree(p2);
p2 = NULL;
}
if(p3)
{
ClearPageReserved(virt_to_page(p3));
kfree(p3);
p3 = NULL;
}
remove_proc_entry(MEM_SHARE_ADDR, mem_share_dir);
remove_proc_entry(MEM_SHARE_SIZE, mem_share_dir);
remove_proc_entry(MEM_SHARE_DIR, NULL);
if(thread_map)
{
kthread_stop(thread_map);
thread_map = NULL;
}
}
module_init(init_kernel_map);
module_exit(exit_kernel_map);

复制代码

用户态：
[code]#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#define MEM_SIZE 100
#define MEM_ADDR_SIZE 32
#define PAGE_SIZE 4096
unsigned long addr;
unsigned long addr_cnt_size;
char _addr[MEM_ADDR_SIZE];
char addr_cnt_len[MEM_ADDR_SIZE];
char _buf[MEM_SIZE];
char *map_addr;
int get_mem(int fd, unsigned long _addr, char *buf, unsigned long size)
{
unsigned long size_cpy;
size_cpy = size;
if(size % PAGE_SIZE)
size = (size / PAGE_SIZE + 1) << 12;
else
size = (size / PAGE_SIZE) << 12;
map_addr =(char *)mmap(0, size , PROT_READ | PROT_WRITE, MAP_SHARED, fd, _addr);
perror("mmap");
if(!map_addr)
{
return 0;
}
memcpy(buf, map_addr, size_cpy);
munmap(map_addr, size);
return 1;
}
int main(int argc, char *argv[])
{
int fd;
int fd_addr;
int fd_size;
int i;
i = 0;
fd = open("/dev/mem", O_RDWR);
fd_addr = open("/proc/mem_share_dir/mem_share_addr", O_RDWR);
fd_size = open("/proc/mem_share_dir/mem_share_size", O_RDWR);
while(1)
{
if(i == 0 || !addr_cnt_size){
memset(_addr, 0, MEM_ADDR_SIZE);
map_addr = NULL;
read(fd_addr, _addr, MEM_ADDR_SIZE);
printf("%s\n", _addr);
addr = atol(_addr);
if(addr == 0)
continue;
printf("addr = %u[%8lx]\n", addr);
memset(addr_cnt_len, 0, MEM_ADDR_SIZE);
read(fd_size, addr_cnt_len, MEM_ADDR_SIZE);
addr_cnt_size = atol(addr_cnt_len);
printf("size = %u[%8lx]\n", addr_cnt_size);
if(get_mem(fd, addr, _buf, addr_cnt_size))
{
i++;
printf("mem_cnt = %s\n", _buf);
}
}
sleep(100);
if(i == 3)
{
break;
}
}
close(fd_addr);
close(fd_size);
close(fd);
}