Chinaunix首页 | 论坛 | 博客

它山之石

首页　| 　博文目录　| 　关于我

lslp88

  • 博客访问： 91971
  • 博文数量： 30
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 45
  • 用 户 组： 普通用户
  • 注册时间： 2014-06-12 15:01
个人简介

蒹霞苍苍白露为霜

文章分类

全部博文（30）

文章存档

2016年（1）

2015年（5）

2014年（24）

我的朋友
最近访客
推荐博文
相关博文
1.从 globalmem 学习 linux字符设备驱动

分类： LINUX

2014-06-12 15:19:56

原文地址：1.从 globalmem 学习 linux字符设备驱动 作者：yuweixian4230

本文的copyright归yuweixian4230@163.com 所有，使用GPL发布，可以自由拷贝，转载。但转载请保持文档的完整性，注明原作者及原链接，严禁用于任何商业用途。
作者：yuweixian4230@163.com
博客：yuweixian4230.blog.chinaunix.net  

书籍：linux设备驱动开发详解 第6章

1 cdev结构体
在linux2.6中，使用cdev结构体描述了一个字符设备，定义如下地址：
  1. 12struct cdev {
  2.   13 struct kobject kobj;    内嵌的kobject对象
  3.   14 struct module *owner;   所属模块 
  4.   15 const struct file_operations *ops;
  5.   16 struct list_head list; 双链表，struct list_head{struct list_head *next,*prev}
  6.   17 dev_t dev;             设备号
  7.   18 unsigned int count;
  8.   19};
cdev结构体的dev_t成员定义了设备号，为32bit，12bit主设备号，20bit次设备号
从下面宏从dev_t获得主设备号和次设备号
查看linux内核中，已经使用的设备号 src/Documentation/devices.txt
  1. 定义在include/linux/kdev_t.h
  2. 通过dev_t获得 主次设备号
  3. 7 #define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))
  4. 8 #define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))
  5. 通过主次设备号，获取 dev_t
  6. 9 #define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi))
cdev结构体的另一个重要成员 file_operations定义了字符设备驱动提供给虚拟文件系统的接口函数

内核提供了一组函数用于操作cdev结构体src/linux/include/linux/cdev.h
  1. 21 void cdev_init(struct cdev *, const struct file_operations *);
  2. 23 struct cdev *cdev_alloc(void);
  3. 25 void cdev_put(struct cdev *p);
  4. 27 int cdev_add(struct cdev *, dev_t, unsigned);
  5. 29 void cdev_del(struct cdev *);
  6. 31 int cdev_index(struct inode *inode);
  7. 33 void cd_forget(struct inode *);
  8. 35 extern struct backing_dev_info directly_mappable_cdev_bdi;
 1.1 cdev_init
函数用于初始化cdev的成员，并建立生cdev和file_operations之间连接
  1. /fs/char_dev.c 2.6.35
  2.  550 void cdev_init(struct cdev *cdev, const struct file_operations *fops)
  3.  551 {
  4.  552 memset(cdev, 0, sizeof *cdev);
  5.  553 INIT_LIST_HEAD(&cdev->list); //初始化链表  与 cdev_alloc 一致
  6.  554 kobject_init(&cdev->kobj, &ktype_cdev_default);//初始化 kobject 对象
  7.  555 cdev->ops = fops; //将传入的fops 传递给 cdev结构体
  8.  556 }
1.2 cdev_alloc()
用于动态申请一个cdev内存
  1. /fs/char_dev.c 2.6.35
  2.  532 struct cdev *cdev_alloc(void)
  3.  533 {
  4.  534 struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);
  5.  535 if (p) {
  6.  536 INIT_LIST_HEAD(&p->list);
  7.  537 kobject_init(&p->kobj, &ktype_cdev_dynamic);
  8.  538 }
  9.  539 return p;
  10.  540 }
对如何使用 cdev_init 和 cdev_alloc查看博文“cdev_init和cdev_alloc使用”

1.3cdev_add()和cdev_del()
向系统添加和删除一个cdev
  1. src/fs/char_dev.c

  3.  480 int cdev_add(struct cdev *p, dev_t dev, unsigned count)//count表示什么？？？
  4.  481 {
  5.  482 p->dev = dev;
  6.  483 p->count = count;
  7.  484 return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);
  8.  485 }
dev_t_ num 是 12bit主设备号+20次设备号
count 表示设备的数量,通常情况下是1，我现在碰到的代码中都是 1
2012.1.3号更新注释说明count用法：
dev_t dev; 假设这个设备号=主设备250，第一个次设备号0，第二个次设备号为1 
cdev_add(&cdev,dev,1);//添加第一个 c 250 0 的设备
cdev_add(&cdev,dev+1,1);//添加第二个 c 250 1 的设备


  2.  499 void cdev_del(struct cdev *p)
  3.  500 {
  4.  501 cdev_unmap(p->dev, p->count);
  5.  502  kobject_put(&p->kobj);
  6.  503 }

2.分配和释放设备号

在调用cdev_add()函数向系统注册字符设备之前，应首先调用register_chrdev_region()或alloc_chrdev_region()函数向系统申请设备号，
register_chrdev_region()函数用于已知起始设备的设备号的情况，而alloc_chrdev_region()用于设备号未知，向系统动态申请未被占用的设备号的情况。
unregister_chrdev_region(dev_t from,unsigned count)；注销字符设备
函数原型为：
  1. src/fs/char_dev.c
  2. dev_t from:   设备号 ，必须包含主设备号  
  3. unsigned count:  申请的 设备数量
  4. const char *name:
  5. 193  int register_chrdev_region(dev_t from, unsigned count, const char *name)
  6.  194 {
  7.  195 struct char_device_struct *cd;
  8.  196 dev_t to = from + count;
  9.  197 dev_t n, next;
  10.  198
  11.  199 for (n = from; n < to; n = next) {
  12.  200 next = MKDEV(MAJOR(n)+1, 0);
  13.  201 if (next > to)
  14.  202 next = to;
  15.  203 cd = __register_chrdev_region(MAJOR(n), MINOR(n),
  16.  204 next - n, name);
  17.  205 if (IS_ERR(cd))
  18.  206 goto fail;
  19.  207 }
  20.  208 return 0;
  21.  209 fail:
  22.  210 to = n;
  23.  211 for (n = from; n < to; n = next) {
  24.  212 next = MKDEV(MAJOR(n)+1, 0);
  25.  213 kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
  26.  214 }
  27.  215 return PTR_ERR(cd);
  28.  216 }
  1. dev_t *dev:生成的设备号，放入*dev指针中
  2. unsigned baseminor：次设备号开始数值，一般为0，现在我碰到的代码中 都为 0
  3. ussigned count:设备数量
  4. dev_t devno;//主次设备号
  5. alloc_chrdev_region(&devno,0,2,"ywxdevice");
假如动态分配的主设备号为250：那么我将注册 c 250 0
                                     c  250 1 两个设备节点
  1. 229   int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)
  2.  231  {
  3.  232 struct char_device_struct *cd;
  4.  233   cd = __register_chrdev_region(0, baseminor, count, name);
  5.  234   if (IS_ERR(cd))
  6.  235   return PTR_ERR(cd);
  7.  236   *dev = MKDEV(cd->major, cd->baseminor);
  8.  237   return 0;
  9.  238  }
  1. 304  void unregister_chrdev_region(dev_t from, unsigned count)
  2.  305 {
  3.  306 dev_t to = from + count;
  4.  307 dev_t n, next;
  5.  308
  6.  309 for (n = from; n < to; n = next) {
  7.  310 next = MKDEV(MAJOR(n)+1, 0);
  8.  311 if (next > to)
  9.  312 next = to;
  10.  313 kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
  11.  314 }
  12.  315 }

3.file_operations结构体
  1. src/include/linux/fs.h

  3. 1485 struct file_operations {
  4. 1486 struct module *owner;
  5. 1487 loff_t (*llseek) (struct file *, loff_t, int);
  6. 1488 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
  7. 1489 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
  8. 1490 ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
  9. 1491 ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
  10. 1492 int (*readdir) (struct file *, void *, filldir_t);
  11. 1493 unsigned int (*poll) (struct file *, struct poll_table_struct *);
  12. 1494 int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
  13. 1495 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
  14. 1496 long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
  15. 1497 int (*mmap) (struct file *, struct vm_area_struct *);
  16. 1498 int (*open) (struct inode *, struct file *);
  17. 1499 int (*flush) (struct file *, fl_owner_t id);
  18. 1500 int (*release) (struct inode *, struct file *);
  19. 1501 int (*fsync) (struct file *, int datasync);
  20. 1502 int (*aio_fsync) (struct kiocb *, int datasync);
  21. 1503 int (*fasync) (int, struct file *, int);
  22. 1504 int (*lock) (struct file *, int, struct file_lock *);
  23. 1505 ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
  24. 1506 unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
  25. 1507 int (*check_flags)(int);
  26. 1508 int (*flock) (struct file *, int, struct file_lock *);
  27. 1509 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
  28. 1510 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
  29. 1511 int (*setlease)(struct file *, long, struct file_lock **);
  30. 1512};
open使用查看“1.2 file_operations open 使用”


globalmem程序代码： globalmem.rar   将rar修改为tar.bz2
  1. #include <linux/module.h>//MODULE_LICENSE() module_init
  2. #include <linux/init.h>//__init __exit
  3. #include <linux/fs.h>//register_chrdev_region
  4. #include <linux/kernel.h>//contain_of kmalloc kfree printk
  5. #include <linux/cdev.h>//struct cdev cdev;
  6. #include <linux/errno.h>
  7. //#include <linux/mm.h>
  8. //#include <linux/sched.h>
  9. #include <linux/types.h>// MAJOR(dev_t dev) MKDEV
  10. //#include <asm/io.h>
  11. //#include <asm/system.h>
  12. #include <asm/uaccess.h> //copy_to_user copy_from_user

  14. #include <linux/stat.h>//00666
  15. #include <linux/slab.h>//kmalloc kfree
  16. #include <linux/moduleparam.h>//module_param()

  18. #define GLOBALMEM_SIZE 0x1000
  19. #define MEM_CLEAR 0x1
  20. #define GLOBALMEM_MAJOR 240 //240-250 LOCAL/EXPERIMENTAL USE

  22. static int globalmem_major = GLOBALMEM_MAJOR;
  23. module_param(globalmem_major,int,S_IRUGO);

  25. struct globalmem_dev{
  26.     struct cdev cdev;
  27.     unsigned char mem[GLOBALMEM_SIZE];
  28. };
  29. struct globalmem_dev *globalmem_devp;

  31. int globalmem_open(struct inode *inode,struct file *filp)
  32. {
  33.     struct globalmem_dev *dev;
  34.     //将设备结构体指针赋值给文件私有数据指针
  35.     dev = container_of(inode->i_cdev,struct globalmem_dev,cdev);
  36.     filp->private_data = dev;
  37.     return 0;
  38. }

  40. int globalmem_release(struct inode *inode,struct file *filp)
  41. {
  42.     return 0;
  43. }
  44. static int globalmem_ioctl(struct inode *inode,struct file *filp,unsigned int cmd,unsigned long arg)
  45. {
  46.     struct globalmem_dev *dev = filp->private_data;
  47.     switch(cmd)
  48.     {
  49.         case MEM_CLEAR:
  50.             memset(dev->mem,0,GLOBALMEM_SIZE);
  51.             printk(KERN_INFO"globalmem is set to zero\n");
  52.             break;
  53.         default:
  54.             return -EINVAL;//22 invaild arguments
  55.     }
  56.     return 0;
  57. }
// read write 看博文“1.3 file_operations read write 使用”
  1. //size 要复制的数据字节数
  2. //loff_t *ppos ：在文件中的位置
  3. static ssize_t globalmem_read(struct file *filp,char __user *buf,size_t size,loff_t *ppos)
  4. {
  5.     unsigned long p = *ppos;//p在文件中的位置，范围[0,GLOBALMEM_SIZE-1]
  6.     unsigned int count = size; //读取的 字节数 
  7.     int ret = 0;
  8.     struct globalmem_dev *dev = filp->private_data;//获得设备结构体指针
  9.     if(p >= GLOBALMEM_SIZE)// 超出 GLOBALMEM_SIZE大小，
  10.         return 0;
  11.     if(count > GLOBALMEM_SIZE - p)//读取的数据 超出范围
  12.         count = GLOBALMEM_SIZE - p;
  13.     if(copy_to_user(buf,(void *)(dev->mem+p),count))
  14.     {
  15.         ret = -EFAULT;//bad address
  16.     }
  17.     else
  18.     {
  19.         *ppos += count;//ppos在文件中的位置，重新设置
  20.         ret = count;
  21.         printk(KERN_INFO"read %u byte(s) form %lu\n",count,p);
  22.     }
  23.     return ret;
  24. }

  26. static ssize_t globalmem_write(struct file *filp,const char __user *buf,size_t size,loff_t *ppos)
  27. {
  28.     unsigned long p = *ppos;//在文件中位置，范围[0,GLOBALMEM_SIZE-1]
  29.     unsigned int count = size;//读数据的 字节数 
  30.     int ret = 0;
  31.     struct globalmem_dev *dev = filp->private_data;

  33.     if(p >= GLOBALMEM_SIZE)
  34.         return 0;
  35.     if(count > GLOBALMEM_SIZE- p)
  36.         count = GLOBALMEM_SIZE - p;
  37.     if(copy_from_user(dev->mem + p,buf,count))
  38.         ret = -EFAULT;//bad address
  39.     else
  40.     {
  41.         *ppos += count;
  42.         ret = count;
  43.         printk(KERN_INFO"written %u byte(s) from %lu\n",count,p);
  44.     }
  45.     return ret;
  46. }
//loff_t offset:在文件中的位置 [0,GLOBALMEM_SIZE]
//int orig:命令
  1. static loff_t globalmem_llseek(struct file *filp,loff_t offset,int orig)
  2. {
  3.     loff_t ret = 0;
  4.     switch(orig)
  5.     {
  6.         case 0:
  7.             if(offset < 0)
  8.             {
  9.                 ret = -EINVAL;//
  10.                 break;
  11.             }
  12.             if((unsigned int)offset > GLOBALMEM_SIZE)
  13.             {
  14.                 ret = -EINVAL;
  15.                 break;
  16.             }
  17.             filp->f_pos = (unsigned int)offset;
  18.             ret = filp->f_pos;
  19.             break;
  20.         case 1:
  21.             if((filp->f_pos + offset) > GLOBALMEM_SIZE)
  22.             {
  23.                 ret = -EINVAL;    
  24.                 break;
  25.             }
  26.             if((filp->f_pos + offset) < 0)
  27.             {
  28.                 ret = -EINVAL;
  29.                 break;
  30.             }
  31.             filp->f_pos +=offset;
  32.             ret = filp->f_pos;
  33.             break;
  34.         default:
  35.             ret = -EINVAL;
  36.             break;
  37.     }
  38.     return ret;
  39. }

  41. static const struct file_operations globalmem_fops={
  42.     .owner = THIS_MODULE,
  43.     .llseek = globalmem_llseek,
  44.     .read = globalmem_read,
  45.     .write = globalmem_write,
  46.     .ioctl = globalmem_ioctl,
  47.     .open = globalmem_open,
  48.     .release = globalmem_release,
  49. };

  51. static void globalmem_setup_cdev(struct globalmem_dev *dev,int index)
  52. {
  53.     int err,devno = MKDEV(globalmem_major,index);
  54.     cdev_init(&dev->cdev,&globalmem_fops);
  55.     dev->cdev.owner = THIS_MODULE;
  56.     err = cdev_add(&dev->cdev,devno,1);
  57.     if(err)
  58.         printk(KERN_INFO"error %d ading globalmem %d",err,index);
  59. }

  61. static int __init globalmem_init(void)
  62. {
  63.     int result;
  64.     dev_t devno = MKDEV(globalmem_major,0);
  65.     if(globalmem_major)
  66.     {
  67.         result = register_chrdev_region(devno,1,"globalmem");
  68.         printk("register_chrdev_region\n");
  69.     }
  70.     else
  71.     {
  72.         result = alloc_chrdev_region(&devno,0,1,"globalmem");
  73.         globalmem_major = MAJOR(devno);
  74.         printk("alloc_chrdev_region\n");
  75.     }
  76.     if(result < 0)
  77.         return result;
  78.      //可以使用 zmalloc申请内核空间，这样就不需要memset重新清空内存了，zmalloc已经完成清空内存操作
  79.     globalmem_devp = kmalloc(sizeof(struct globalmem_dev),GFP_KERNEL);
  80.     if(!globalmem_devp)    
  81.     {
  82.         result = -ENOMEM;//no memory
  83.         goto fail_malloc;
  84.     }
  85.     memset(globalmem_devp,0,sizeof(struct globalmem_dev));
  86.     globalmem_setup_cdev(globalmem_devp,0);

  88.     printk("init finished..\n");
  89.     return 0;
  90. fail_malloc:
  91.     unregister_chrdev_region(devno,1);
  92.     return result;
  93. }

  95. static void __exit globalmem_exit(void)
  96. {
  97.     cdev_del(&globalmem_devp->cdev);
  98.     kfree(globalmem_devp);
  99.     unregister_chrdev_region(MKDEV(globalmem_major,0),1);
  100.     printk("exit..\n");
  101. }
  102. MODULE_AUTHOR("Song");
  103. MODULE_LICENSE("GPL");

  105. module_init(globalmem_init);
  106. module_exit(globalmem_exit);

操作过程：
1. 插入模块文件，在程序代码中，主设备号设置为 240
  1. ywx@ywx:~/Desktop/module/baohua/globalmem$ sudo insmod ./globalmem.ko
  2. ywx@ywx:~/Desktop/module/baohua/globalmem$ cat /proc/devices
  3. Character devices:
  4.   1 mem
  5.   4 /dev/vc/0
  6. 136 pts
  7. 180 usb
  8. 189 usb_device
  9. 240 globalmem

2.新建设备文件，并测试
  1. root@ywx:/home/ywx/desktop# mknod /dev/globalmem c 240 0
  2. root@ywx:/home/ywx/desktop# echo "i love linux" > /dev/globalmem
  3. root@ywx:/home/ywx/desktop# cat /dev/globalmem
  4. i love linux
当使用 mknod /dev/globalmem c 240 1的时候，会出错。因为在程序代码中只申请了一个设备，次设备号为0，如果需要多个次设备，需要在程序代码中修改并增加设备数量及次设备号。


3. 参看/proc/modules 和 /sys/modules/globalmem 
 系统中多了 globalmem 这个设备
  1. ywx@ywx:~/desktop$ cat /proc/modules | grep glo
  2. globalmem 1816 0 - Live 0xe0a27000

  4. ywx@ywx:~/desktop$ ls /sys/module/globalmem/
  5. holders initstate notes parameters refcnt sections srcversion

4. dmesg 测试程序代码 printk
  1. root@ywx:/home/ywx/desktop# dmesg | tail -4
  2. [ 6439.327891] register_chrdev_region
  3. [ 6439.327958] init finished..
  4. [ 6555.013116] written 13 byte(s) from 0
  5. [ 6558.571373] read 4096 byte(s) form 0

5. 测试 动态设备节点
 当major主设备号为0时，系统会自动设置并分配空闲的主设备号，注意，主设备号240-250是用于 实验 使用的。所以当我们自动分配主设备号时，经常是分配250这个主设备号
  1. ywx@ywx:~/desktop/module/baohua/globalmem$ sudo insmod ./globalmem.ko globalmem_major=0
  2. ywx@ywx:~/desktop/module/baohua/globalmem$ cat /proc/devices
  3. Character devices:
  4.   1 mem
  5.   4 /dev/vc/0
  6. 128 ptm
  7. 136 pts
  8. 180 usb
  9. 189 usb_device
  10. 250 globalmem
6. 使用程序代码测试 将rar修改为tar.bz2
  1. #include <stdio.h>//printf memset
  2. #include <unistd.h>
  3. #include <fcntl.h>//
  4. #include <linux/stat.h>//S_IRUSR=00600
  5. #include <stdlib.h>//exit
  6. #include <string.h>//strcpy

  8. int main(int argc, char **argv)
  9. {
  10.     int fd = 0;
  11.     int ret = 0;
  12.     char buf[10];
  13.     
  14.     //clear memory
  15.     memset(buf,'a',10);
  16.     printf("%s\n",buf);
  17.     
  18.     //open
  19.     fd = open("/dev/globalmem",O_RDWR,S_IRUSR|S_IWUSR);

  21.     //write
  22.     ret = write(fd,"yuweixian",strlen("yuweixian"));//attentions: "\n"

  24.     //lseek set to file offset
  25.     ret = lseek(fd,0,SEEK_SET);

  27.     //read
  28.     ret = read(fd,buf,strlen(buf));
  29.     printf("%s\n",buf);

  31.     close(fd);
  32.     exit(EXIT_SUCCESS);
  33. }
  1. root@ywx:/home/ywx/desktop/module/baohua/globalmem# ./app
  2. aaaaaaaaaa
  3. yuweixian

当使用 cat /dev/globalmem，显示如下：
在显示 “yuweixian” 打印信息后，/dev/globalmem内存中还有很多其他混乱的数据，这是因为我们没有输入结束符






















阅读(1067) | 评论(0) | 转发(0) |
0

上一篇：linux设备驱动归纳总结（三）：1字符型设备之设备申请

下一篇：1.1 cdev_init cdev_alloc 使用说明

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6