阻塞性驱动编写

晨曦之光 发布于 2012/04/13 11:20
阅读 117
收藏 0

memdevQueue.c和memdevQueue.h是驱动程序,另有两个测试程序,当设备中无数据可读时候阻塞进程,然后调用另一个测试程序向设备写入数据,此时设备中有数可以读取,则唤醒读进程,从设备中读取数据。

驱动程序

memdevQueue.h

#include<linux/ioctl.h>  //包含ioctl已经命令定义等
#ifndef _MEMDEV_H_
#define _MEMDEV_H_

#ifndef MEMDEV_MAJOR
#define MEMDEV_MAJOR 250   /*预设的mem的主设备号*/
#endif

#ifndef MEMDEV_NR_DEVS
#define MEMDEV_NR_DEVS 2    /*设备数*/
#endif

#ifndef MEMDEV_SIZE
#define MEMDEV_SIZE 4096
#endif

/*mem设备描述结构体*/
struct mem_dev                                    
{                                                       
  char *data;                     
  unsigned long size; 
  wait_queue_head_t my_read_queue; //在设备描述结构中添加读取等待队列,等待队列是属于设备的
};


/*定义命令所用的幻数和命令*/
#define MEMDEV_IOC_MAGIC 'm'  //命令的类型占用八位,可以用字符型来代替,当然也可以用0x**,这样一个十六进制数字来定义命令类型type,type用来指定命令所属于那一个设备
#define MEMDEV_IOCPRINT   _IO(MEMDEV_IOC_MAGIC,1)
#define MEMDEV_IOCGETDATA _IOR(MEMDEV_IOC_MAGIC,2,int)  //从设备中读取数据
#define MEMDEV_IOCSETDATA _IOW(MEMDEV_IOC_MAGIC,3,int)   //向设备中写入命令

#define MEMDEV_NUMBER 3  //定义命令的最大数,可以用来控制判段命令的有效性

#endif /* _MEMDEV_H_ */

 


memdevQueue.C

 #include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <linux/slab.h>   //include in kmalloc and kfree
#include "memdevQueue.h"

static int mem_major = MEMDEV_MAJOR;   //预设的主设备号254,在头文件中定义

module_param(mem_major, int, S_IRUGO);

struct mem_dev *mem_devp; /*设备结构体指针,后面我们要为他分配内存,定义一个结构体指针,mem_devp要指向一个结构体,我们自然要为这个结构体分配空间,如果结构体中还有指针,我们还要为结构体中的指针分配空间*/

struct cdev cdev;

bool  have_data=false;   //标示设备中是否有数据可以读,初始化为FALSE没有数据可以读取

/*文件打开函数*/
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; //操作的文件和对应的设备绑定起来,保存起来对应的struct inode,因为在其它函数里面,我们没法打开struct inode,来确定要操作的物理文件是哪个
   
    return 0;
}

/*ioctl函数,用来控制设备*/
int mem_ioctl(struct inode *inode,struct file *filp,unsigned int cmd,unsigned long arg)

 int err=0;
 int date_buffer=0;
 if(_IOC_TYPE(cmd)!=MEMDEV_IOC_MAGIC)  //提取出来命令的 类型 ,检查该命令是不是该设备的
 {
   return -EINVAL;
 }
 if(_IOC_NR(cmd)>MEMDEV_NUMBER)   //检查传来的命令的 序号 有没有超过命令的最大数,超过了说明命令非法
 {
   return -EINVAL;
 }
 //通过了上面的检查,说明该命令合法,下面要检查该命令如果带有参数,检查参数的合法性,要分为读和写两个方面来检查
 if(_IOC_DIR(cmd)&_IOC_READ)  //_IOC_DIR是检查命令的方向,和_iOC_READ与运算后如果为1,表示是读的命令,要检查参数空间是否可写
  err=!access_ok(VERIFY_WRITE,(void *)arg,_IOC_SIZE(cmd));
 else if(_IOC_DIR(cmd)&_IOC_WRITE)
  err=!access_ok(VERIFY_READ,(void *)arg,_IOC_SIZE(cmd));  //access_ok检查空间的可用性,如果不可用,失败,则返回0
 if(err)
  return -EFAULT;
 
 /*根据命令,执行相应的操作*/
 switch(cmd)
 {
  case MEMDEV_IOCPRINT:
   printk("<0>The device recieve MEMDEV_IOCPRINT command!/n/n");
   break;
  case MEMDEV_IOCGETDATA:
   date_buffer=1111;
   err=__put_user(date_buffer,(int *)arg);  //吧数据写入到用户空间arg中
   break;
  case MEMDEV_IOCSETDATA:
   err=__get_user(date_buffer,(int *)arg);  //从用户空间arg中读取数据,写入到buffer里面保存起来。
   printk("<0>Get from user arg %d/n",date_buffer);
   break;
  default:
   printk("<0>cmd  wrong!");
   return -EFAULT;
 }
 return err;
}


/*文件释放函数*/
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; /*获得设备结构体指针*/
   //struct mem_dev *dev=dev; //在open时候保存的次设备,因为我们在mem_read函数里面是没法获得次设备号的,我们就不知道操作的是哪一个设备,所以在open时候,我们把次设备号提取出来,保存到打开的file结构体里面
  /*判断读位置是否有效*/
  if (p >= MEMDEV_SIZE)
    return 0;   //读取的位置大于文件的大小,读取失败
  if (count > MEMDEV_SIZE - p)
    count = MEMDEV_SIZE - p;  //要读取的大小大于文件指针到文件结尾的大小,改变读取的数据量大小

 //然后判断是否有数据可以读取,没有数据读取时候,并且阻塞后,要一直循环,假如被唤醒,要看有没有数据,没有数据时候要继续在阻塞,除非在write中写入了数据have_data置为了1
 //这时候才不会阻塞
 while(!have_data)
 {
 // if(filp->f_flags & O_NONBLOCK)
 //  return -EAGAIN;  //设置了非阻塞标志位,没有数据时候立即返回,
  printk(KERN_EMERG "读数据进程阻塞.../n");
  wait_event_interruptible(dev->my_read_queue,have_data); //把该进程阻塞,加入到该打开设备的读取阻塞队列
 }
 
  /*读数据到用户空间*/
  if (copy_to_user(buf, (void*)(dev->data + p), count))
  {
 printk("<0>copy_to_user failed.../n");
    ret =  - EFAULT;
  }
  else
  {
    *ppos += count;  //修改文件中指针,
    ret = count;   //把读到的数据量大小返回
   
    printk(KERN_INFO "read %d bytes(s) from %d/n", count, p);
  }

  have_data=false;  //在唤醒进程,并且读取了数据后,没有数据可以读了,应该把标志位置为
  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);
  }
 printk(KERN_EMERG "write message: %s/n",dev->data);
  //写入了了数据后,有新数据可以读取了,可以唤醒进程了
  have_data=true;   //更改标志
  wake_up(&(dev->my_read_queue));   //唤醒进程
 
  return ret;
}

/* seek文件定位函数 ,每个file_operation里面的函数都有struct file *filp这个参数*/
static loff_t mem_llseek(struct file *filp, loff_t offset, int whence) //后两个参数是从llseek()里面传递下来的
{
    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,
  .ioctl=mem_ioctl,
};

/*设备驱动模块加载函数*/
static int memdev_init(void)
{
  int result;
  int i;

  dev_t devno = MKDEV(mem_major, 0);  //MKDEV宏把主设备号254和此设备号0共同构成一个设备号

  /* 静态申请设备号*/
  if (mem_major)  //mem_major 非零时候静态分配设备号
    result = register_chrdev_region(devno, 2, "memdev"); //从devno开始注册2设备号,设备名是memdev
  else  /* 动态分配设备号 */
  {
    result = alloc_chrdev_region(&devno, 0, 2, "memdev"); //次设备号从0开始
    mem_major = MAJOR(devno);  //取出主设备号
  } 
 
  if (result < 0)
    return result;

  /*初始化cdev结构*/
  //前面我们通过struct  cdev cdev分配了设备结构,这里不用*cdev_alloc(void )来分配设备了
  cdev_init(&cdev, &mem_fops);  //绑定文件操作函数集,两个参数都是指针
  cdev.owner = THIS_MODULE;   //.owner这表示谁拥有你这个驱动程序,
  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);
 
   
  //既然是阻塞性设备驱动程序,那么在初始化模块时候应该初始化读取数据阻塞的队列
  init_waitqueue_head(&(mem_devp[i].my_read_queue));  //注意参数是指针
  }   
  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("David Xie");
MODULE_LICENSE("GPL");

module_init(memdev_init);
module_exit(memdev_exit);

 

写数据测试程序:

//开辟内存作为设备,刚开始没有数据可以读,然后阻塞读的进程,当有数据可以读时候唤醒这个进程,本程序负责写入数据,然后从等待队列中唤醒阻塞进程
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
int main()
{
 int fd;
 char Buf[4096];
 
 /*初始化Buf*/
 strcpy(Buf,"ECJTU CERT xiesiyuan");
 printf("WRITE BUF: %s/n",Buf);
 
 /*打开设备文件*/ 
 fd=open("/dev/memdev_Q",O_RDWR);
 if (fd == NULL)
 {
  printf("WRITE Open Memdev0 Error!/n");
  return -1;
 }
 
 /*写入设备*/
 if(write(fd,Buf, sizeof(Buf))<0)
 {
  printf("WRITE write to dev error!/n");
  return -1;
 }
 close(fd);
 return 0; 

}
读设备测试程序:

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>

int main()
{
 FILE *fp0 = NULL;
 char Buf[4096];
 
 /*初始化Buf*/
 strcpy(Buf,"Mem is char dev!");
 printf("READ: befor read BUF: %s/n",Buf);
 
 /*打开设备文件*/
 fp0 = fopen("/dev/memdev_Q","r+");
 if (fp0 == NULL)
 {
  printf("READ Open Memdev0 Error!/n");
  return -1;
 }
 fseek(fp0,0,SEEK_SET);

 /*读出设备*/
 fread(Buf, sizeof(Buf), 1, fp0);
 
 /*检测结果*/
 printf("READ:After read BUF: %s/n",Buf);
 
 return 0; 
}

在读程序中也可以使用open,read等标准系统调用

 


原文链接:http://blog.csdn.net/xie376450483/article/details/5725182
加载中
返回顶部
顶部