要求：基于Linux的内存模拟型的字符IO设备驱动程序的设计，并编写应用程序实现线程间的通信。
基于Linux的内存模拟型的字符IO设备驱动程序的设计
1 内存模拟型的字符IO设备驱动程序memDrv.c
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#define MEMDEV_MAJOR 100 /*预设的mem的主设备号*/
#define MEMDEV_NR_DEVS 2 /*设备数*/
#define MEMDEV_SIZE 4096 /*内存大小*/
/*mem设备描述结构体*/
struct mem_dev
{
char *data;
unsigned long size;
};
static int mem_major = MEMDEV_MAJOR; //定义主设备号
module_param(mem_major, int, S_IRUGO); //模块传参
struct mem_dev *mem_devp; /*设备结构体指针*/
struct cdev cdev;
/*文件打开函数*/
int mem_open(struct inode *inode, struct file *filp)
{
struct mem_dev *dev;
/*获取次设备号*/
int num = MINOR(inode->i_rdev);
if (num >= MEMDEV_NR_DEVS)
return -ENODEV;
dev = &mem_devp[num];
/*将设备描述结构指针赋值给文件私有数据指针*/
filp->private_data = dev;
return 0;
}
/*文件释放函数*/
int mem_release(struct inode *inode, struct file *filp)
{
return 0;
}
/*读函数*/
static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
unsigned long p = *ppos; /*记录文件指针偏移位置*/
unsigned int count = size; /*记录需要读取的字节数*/
int ret = 0; /*返回值*/
struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/
/*判断读位置是否有效*/
if (p >= MEMDEV_SIZE) /*要读取的偏移大于设备的内存空间*/
return 0;
if (count > MEMDEV_SIZE - p) /*要读取的字节大于设备的内存空间*/
count = MEMDEV_SIZE - p;
/*读数据到用户空间:内核空间->用户空间交换数据*/
if (copy_to_user(buf, (void*)(dev->data + p), count))
{
ret = - EFAULT;
}
else
{
*ppos += count;
ret = count;
printk(KERN_INFO "read %d bytes(s) from %d\n", count, p);
}
return ret;
}
/*写函数*/
static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
{
unsigned long p = *ppos;
unsigned int count = size;
int ret = 0;
struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/
/*分析和获取有效的写长度*/
if (p >= MEMDEV_SIZE)
return 0;
if (count > MEMDEV_SIZE - p) /*要写入的字节大于设备的内存空间*/
count = MEMDEV_SIZE - p;
/*从用户空间写入数据*/
if (copy_from_user(dev->data + p, buf, count))
ret = - EFAULT;
else
{
*ppos += count; /*增加偏移位置*/
ret = count; /*返回实际的写入字节数*/
printk(KERN_INFO "written %d bytes(s) from %d\n", count, p);
}
return ret;
}
/* seek文件定位函数 */
static loff_t mem_llseek(struct file *filp, loff_t offset, int whence)
{
loff_t newpos;
switch(whence) {
case 0: /* SEEK_SET */ /*相对文件开始位置偏移*/
newpos = offset; /*更新文件指针位置*/
break;
case 1: /* SEEK_CUR */
newpos = filp->f_pos + offset;
break;
case 2: /* SEEK_END */
newpos = MEMDEV_SIZE -1 + offset;
break;
default: /* can't happen */
return -EINVAL;
}
if ((newpos<0) || (newpos>MEMDEV_SIZE))
return -EINVAL;
filp->f_pos = newpos;
return newpos;
}
/*文件操作结构体*/
static const struct file_operations mem_fops =
{
.owner = THIS_MODULE,
.llseek = mem_llseek,
.read = mem_read,
.write = mem_write,
.open = mem_open,
.release = mem_release,
};
/*设备驱动模块加载函数*/
static int memdev_init(void)
{
int result;
int i;
dev_t devno = MKDEV(mem_major, 0);
/* 申请设备号，当xxx_major不为0时，表示静态指定；当为0时，表示动态申请*/
/* 静态申请设备号*/
if (mem_major)
result = register_chrdev_region(devno, 2, "memdev");
else /* 动态分配设备号 */
{
result = alloc_chrdev_region(&devno, 0, 2, "memdev");
mem_major = MAJOR(devno); /*获得申请的主设备号*/
}
if (result < 0)
return result;
/*初始化cdev结构，并传递file_operations结构指针*/
cdev_init(&cdev, &mem_fops);
cdev.owner = THIS_MODULE; /*指定所属模块*/
cdev.ops = &mem_fops;
/* 注册字符设备 */
cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);
/* 为设备描述结构分配内存*/
mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev), GFP_KERNEL);
if (!mem_devp) /*申请失败*/
{
result = - ENOMEM;
goto fail_malloc;
}
memset(mem_devp, 0, sizeof(struct mem_dev));
/*为设备分配内存*/
for (i=0; i < MEMDEV_NR_DEVS; i++)
{
mem_devp[i].size = MEMDEV_SIZE;
mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);
memset(mem_devp[i].data, 0, MEMDEV_SIZE);
}
return 0;
fail_malloc:
unregister_chrdev_region(devno, 1);
return result;
}
/*模块卸载函数*/
static void memdev_exit(void)
{
cdev_del(&cdev); /*注销设备*/
kfree(mem_devp); /*释放设备结构体内存*/
unregister_chrdev_region(MKDEV(mem_major, 0), 2); /*释放设备号*/
}
MODULE_AUTHOR("Wenxiaohong");
MODULE_LICENSE("GPL");
module_init(memdev_init);
module_exit(memdev_exit);
2 IO设备驱动实现线程间的通信的程序memIoDrv.c
/* written by wenxiaohong chongqing university at 20211225 */
/* Confidential for Chongqing University */
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <pthread.h>
#include <semaphore.h>
#define memIoDev_NAME "/dev/memDrv"
#define THREAD_NUM 2
#define THREAD1_MSG 3
#define THREAD2_MSG 3
sem_t sem; //semaphore
struct msg { // data structure for msg passing
int tid; // task id
int value; // msg value
};
int memIoFd;
void * thread1_handler(void *arg);
void * thread2_handler(void *arg);
int main()
{
int i;
pthread_t tid[THREAD_NUM];
if(sem_init(&sem, 0, 0) == -1) //初始化信号量，其初值为0
{
perror("semaphore intitialization failed\n");
return 0;
}
if((memIoFd = open(memIoDev_NAME,O_RDWR)) < 0) //打开设备文件
{
printf("open memDrv Error! FD:%d\n",memIoFd);
return 0;
}
else
{
printf("open memDrv sucess!\n");
}
pthread_create(&tid[0], NULL, thread1_handler, NULL); //创建第一个线程
pthread_create(&tid[1], NULL, thread2_handler, NULL); //创建第二个线程
for(i = 0; i < THREAD_NUM; i++)
{
pthread_join(tid[i],NULL);
}
//cleaning semaphore
sem_destroy(&sem);
return 0;
}
void * thread1_handler(void *arg)
{
int count;
int value;
struct msg thread1Item;
printf ("thread1 started: thread1 id = %#x\n", pthread_self());
for (count = 1; count <= THREAD1_MSG; count++)
{
value = count * 10;
//Fill in the data structure for message passing
thread1Item.tid = pthread_self ();
thread1Item.value = value;
//Send Messages
if ((write (memIoFd, (char *)&thread1Item, sizeof (thread1Item))) == 0)
{
perror ("Error in sending the message");
return 0;
}
else
printf ("thread1: id = %#x, sent value = %d \n",
pthread_self(), value);
}
sem_post(&sem); //Acquire a semaphore(+1)
pthread_exit(NULL);
}
void * thread2_handler(void *arg)
{
int count;
struct msg thread2Item;
sem_wait(&sem); //Release the semaphore (-1)
printf ("thread2 started: thread2 id = %#x\n", pthread_self());
lseek(memIoFd,0,SEEK_SET);
for (count = 1; count <= THREAD2_MSG; count++)
{
//Receive Messages
if ((read (memIoFd, (char *)&thread2Item, sizeof (thread2Item))) == 0)
{
perror ("Error in receiving the message");
return 0;
}
else
printf ("thread2: id = %#x, received msg of value %d from tid = %#x\n",
pthread_self(), thread2Item.value, thread2Item.tid);
}
pthread_exit(NULL);
}
3 Makefile文件
Makefile文件将编译memDrv.c编译为设备驱动模块memDrv.ko。
CONFIG_MODULE_SIG=n
# Kernel modules
obj-m += memDrv.o
# Specify flags for the module compilation.
build: kernel_modules
kernel_modules:
make -C /usr/src/linux-headers-$(shell uname -r) M=$(CURDIR) modules
clean:
make -C /usr/src/linux-headers-$(shell uname -r) M=$(CURDIR) clean
4 程序执行步骤
运行环境为：ubantu16.04
4.1 使用make命令
利用make命令将memDrv.c编译为设备驱动模块memDrv.ko。
4.2 查看当前系统中已经注册的字符设备的主设备号
使用cat /proc/devices命令查看当前系统中已经注册的字符设备或者块设备的主设备号。可以看出图3中没有主设备号为100的字符设备，所以我们下一步就加载驱动模块。
4.3 加载设备驱动模块memDrv.ko
使用“insmod”命令加载设备驱动模块memDrv.ko，可以从图中看出主设备号为100的驱动模块已经加载成功。
4.4 创建与memDrv驱动对应的设备节点文件
使用“mknod”命令在/dev目录下创建与memDrv驱动对应的设备节点文件，memIoDrv应用程序就是通过操作这个设备节点文件来完成对memDrv设备的读和写，进而完成线程间通信。
其中“mknod”是创建节点命令 ，“/dev/memDrv”是要创建的节点文件c”表示这是个字符设备，“100”是设备的主设备号，“0”是设备的次设备号。创建完成以后就会存在/dev/memDrv这个文件。
4.5 编译线程间通信程序
使用“gcc”命令编译线程间通信程序，注意此时memIoDrv.c中使用了线程，所以编译命令中要加入**“-lpthread”选项。**
4.6 运行应用程序
使用“sudo ./memIoDrv”运行应用程序，注意需要加上sudo，否则权限不够。下图中可以看出线程1分别写入了三个数据，线程2也读取到了对应的三个数据，与作业二有所不同，Linux中写完一段内存可以自动偏移，而不是覆盖，所以线程2可以读到三个数据。值得注意的是，线程2在读取前，需要使用lseek函数将文件读写指针置于文件头，即将文件偏移量置0。
332
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
