Sysfs文件系统:
"sysfs is a ram-based filesystem initially based on ramfs.It provides a means to exportkernel data structures, their attributes, and the linkages between them to userspace.”
--- documentation/filesystems/sysfs.txt
Linux2.6内核引入了 sysfs 文件系统。sysfs 被看成是与 proc同类别的文件系统。sysfs 把连接在系统上的设备和总线组织成分级的文件,使其从用户空间可以访问到。
Sysfs 被加载在 /sys/ 目录下,它的子目录包括:
block:在系统中发现的每个块设备在该目录下对应一个子目录。每个子目录中又包含一些属性文件,它们描述了这个块设备的各方面属性,如:设备大小。(loop块设备是使用文件来模拟的)
bus:在内核中注册的每条总线在该目录下对应一个子目录, 如:ide pci scsi usb pcmcia
其中每个总线目录内又包含两个子目录:devices 和 drivers
devices目录包含了在整个系统中发现的属于该总线类型的设备,
drivers目录包含了注册到该总线的所有驱动。
class:将设备按照功能进行的分类,如/sys/class/net目录下包含了所有网络接口。
devices:包含系统所有的设备。
kernel:内核中的配置参数
module:系统中所有模块的信息
firmware:系统中的固件
fs:描述系统中的文件系统
power:系统中电源选项
Kobject:
- struct kobject{
- const char *name;
- struct list_head entry;
- struct kobject *parent;//指向父对象
- struct kset *kset;
- struct kobj_type *ktype;
- struct sysfs_dirent *sd;
- struct kref kref;//对象引用计数
- unsigned int state_initialized:1;
- unsigned int state_in_sysfs:1;
- unsigned int state_add_uevent_sent:1;
- unsigned int state_remove_uevent_sent:1;
- };
- void kobject_init(struct kobject * kobj)
- int kobject_add(struct kobject * kobj)
- int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,struct kobject *parent, const char *fmt, ...)
- void kobject_del(struct kobject * kobj)
- struct kobject *kobject_get(struct kobject *kobj)
- void kobject_put(struct kobject * kobj)
Kobject的ktype成员是一个指向kobj_type结构的指针,
该结构中记录了kobject对象的一些属性。
- struct kobj_type{
- void (*release)(struct kobject *kobj);
- struct sysfs_ops *sysfs_ops;
- struct attribute **default_attrs;
- };
- struct attribute{
- char * name; /*属性文件名*/
- struct module * owner;
- mode_t mode;/*属性的保护位*/
- };
- struct sysfs_ops
- {
- ssize_t (*show)(struct kobject *, struct attribute *,char *);
- ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t);
- };
store:当用户写属性文件时,该函数被调用,用于存储用户传入的属性值。
Kobject是用来在/sys/创建目录,而目录下的文件就是其属性文件,其创建的目录下不能再有目录只能有属性文件。
Kset:
kset是具有相同类型的kobject的集合,在sysfs中体现成一个目录,在内核中用kset数据结构表示,定义为:
- struct kset{
- struct list_head list; //连接该kset中所有kobject的链表头
- spinlock_t list_lock;
- struct kobject kobj; //内嵌的kobject
- struct kset_uevent_ops *uevent_ops; //处理热插拔事件的操作集合
- }
Kset操作
- int kset_register(struct kset *kset)
- void kset_unregister(struct kset *kset)
热插拔事件:
在Linux系统中,当系统配置发生变化时,如: 添加kset到系统;移动kobject, 一个通知会从内核空间发送到用户空间,这就是热插拔事件。热插拔事件会导致用户空间中相应的处理程序(如udev,mdev)被调用, 这些处理程序会通过加载驱动程序, 创建设备节等来响应热插拔事件。
操作集合
- struct kset_uevent_ops{
- int (*filter)(struct kset *kset, struct kobject *kobj);
- const char *(*name)(struct kset *kset, struct kobject *kobj);
- int (*uevent)(struct kset *kset, struct kobject *kobj,struct kobj_uevent_env *env);
- }
filter:决定是否将事件传递到用户空间。如果 filter 返回 0,将不传递事件。(例: uevent_filter)
name:用于将字符串传递给用户空间的热插拔处理程序。
uevent:将用户空间需要的参数添加到环境变量中。(例:dev_uevent)
大概地说,Kset就是用来创建其有子目录的的目录,当其子目录所管理的kobject和kset状态发生变化时(如被加入,移动),调用其ops的三个函数。
设备驱动模型:
总线:
总线是处理器和设备之间的通道,在设备模型中, 所有的设备都通过总线相连, 甚至是内部的虚拟“platform”总线。在 Linux 设备模型中, 总线由 bus_type 结构表示, 定义在 <linux/device.h> 。
总线描述:
- struct bus_type{
- const char *name;/*总线名称*/
- struct bus_attribute *bus_attrs;/*总线属性*/
- struct device_attribute *dev_attrs;/*设备属性*/
- struct driver_attribute *drv_attrs;/*驱动属性*/
- int (*match)(struct device *dev, struct device_driver *drv);
- int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
- int (*probe)(struct device *dev);
- int (*remove)(struct device *dev);
- void (*shutdown)(struct device *dev);
- int (*suspend)(struct device *dev, pm_message_t state);
- int (*suspend_late)(struct device *dev, pm_message_t state);
- int (*resume_earl y)(struct device *dev);
- int (*resume)(struct device *dev);
- struct dev_pm_ops *pm;
- struct bus_type_private *p;
- }
- bus_register(struct bus_type* bus)
总线的删除使用:
- void bus_unregister(struct bus_type* bus)
- int (*match)(struct device * dev, struct device_driver * drv)
- int (*uevent)(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size)
总线属性 由结构 bus_attribute 描述,定义如下:
- struct bus_attribute{
- struct attribute attr;
- ssize_t (*show)(struct bus_type *, char * buf);
- ssize_t (*store)(struct bus_type *, const char * buf, size_t count);
- }
- int bus_create_file(struct bus_type *bus, struct bus_attribute *attr)
- void bus_remove_file(struct bus_type *bus, struct bus_attribute *attr)
设备描述:
Linux 系统中的每个设备由一个 struct device 描述:
- struct device{
- …… …… …… …… …… ……
- struct kobject kobj;
- char bus_id[BUS_ID_SIZE]; /*在总线上唯一标识该设备的字符串 */
- struct bus_type *bus; /* 设备所在总线 */
- struct device_driver *driver; /*管理该设备的驱动*/
- void *driver_data; /*该设备驱动使用的私有数据成员 *
- struct klist_node knode_class;
- struct class *class;
- struct attribute_group **groups;
- void (*release)(struct device *dev);
- }
- int device_register(struct device *dev)
设备的注销:
- void device_unregister(struct device *dev)
设备属性由struct device_attribute 描述:
- struct device_attribute
- {
- struct attribute attr;
- ssize_t (*show)(struct device *dev, struct device_attribute *attr,char *buf);
- ssize_t (*store)(struct device *dev, struct device_attribute *attr, const char *buf, size_t count);
- }
- int device_create_file(struct device *device, struct device_attribute * entry)
- void device_remove_file(struct device * dev, struct device_attribute * attr)
驱动描述:
驱动程序由struct device_driver 描述 :
- struct device_driver{
- const char *name;/*驱动程序的名字( 体现在 sy sfs 中 )*/
- struct bus_type *bus;/*驱动程序所在的总线*/
- struct module *owner;
- const char *mod_name;
- int (*probe) (struct device *dev);
- int (*remove) (struct device *dev);
- void (*shutdown) (struct device *dev);
- int (*suspend) (struct device *dev, pm_message_t state);
- int (*resume) (struct device *dev);
- struct attribute_group **groups;
- struct dev_pm_ops *pm;
- struct driver_private *p;
- }
- int driver_register(struct device_driver *drv)
- void driver_unregister(struct device_driver *drv)
驱动的属性使用struct driver_attribute 来描述:
- struct driver_attribute {
- struct attribute attr;
- ssize_t (*show)(struct device_driver *drv, char *buf);
- ssize_t (*store)(struct device_driver *drv, const char*buf, size_t count);
- }
- int driver_create_file(struct device_driver * drv, struct driver_attribute * attr)
- void driver_remove_file(struct device_driver * drv, struct driver_attribute * attr)
关于总线、设备、驱动的一个粗略总结:
初始化总线模块会在/sys/bus/下产生相应名字的一个文件夹(初始化总线必须要将其当成设备注册否则无法挂载设备在其下),加载(初始化)相应的设备模块(该设备的bus和parent和当前总线属性一致)之后会在总线文件夹下的device文件夹产生文件(注意设备模块需要一个release在struct device下,即使该函数是空的,否则在移除模块的时候不会删除相应的文件),加载相应的驱动模块会在总线文件夹下的driver文件夹下产生文件,关于driver和device是否匹配是由总线模块完成的(match函数),过程是总线ID和驱动名是否一致,如果一致则调用驱动模块中的probe,正因为总线模块做了匹配工作,所以不管设备和驱动加载的先后顺序如何,总线都会将它们匹配起来。
另外需要注意的几个宏定义:BUS_ATTR、DEVICE_ATTR、DRIVER_ATTR。
Platform总线
platform_device和platform_driver
- struct platform_device{
- const char *name; /*设备名*/
- int id; /*设备编号,配合设备名使用*/
- struct device dev;
- u32 num_resources;
- struct resource *resource; /*设备资源*/
- }
- struct platform_device *platform_device_alloc(const char*name, int id)
name: 设备名
id: 设备id,一般为-1
注册平台设备,使用函数:
- int platform_device_add(struct platform_device *pdev)
- struct resource{
- resource_size_t start; //资源的起始物理地址
- resource_size_t end; //资源的结束物理地址
- const char *name; //资源的名称
- unsigned long flags; //资源的类型,比如MEM,IO,IRQ类型
- struct resource *parent, *sibling, *child; //资源链表指针
- }
- static struct resource s3c_wdt_resource1 ={
- .start = 0x44100000,
- .end = 0x44200000,
- .flags = IORESOURCE_MEM,
- }
- static struct resource s3c_wdt_resource2 ={
- .start = 20,
- .end = 20,
- .flags = IORESOURCE_IRQ,
- }
- struct resource*platform_get_resource(struct platform_device *dev, unsignedint type, unsignedint num)
dev: 资源所属的设备
type: 获取的资源类型
num: 获取的资源数
例:
- platform_get_resource(pdev, IORESOURCE_IRQ, 0)
平台驱动使用struct platform_driver 描述:
- struct platform_driver{
- int (*probe)(struct platform_device *);
- int (*remove)(struct platform_device *);
- void (*shutdown)(struct platform_device *);
- int (*suspend)(struct platform_device *,pm_message_t state);
- int (*suspend_late)(struct platform_device *, pm_message_t state);
- int (*resume_early)(struct platform_device *);
- int (*resume)(struct platform_device *);
- struct device_driver driver;
- }
- int platform_driver_register(struct platform_driver *)
因为platform是系统集成的,所以不需要注册总线,那么判断驱动和设备是否匹配的关键就在于它们的名字是否相同(而关于驱动和设备加载的前后顺序对于匹配也无影响,可能是内核MATCH)。
中断处理:
2.实现中断处理函数
- int request_irq(unsigned int irq, void (*handler)(int, void*,struct pt_regs *), unsigned long flags, const char*devname, void *dev_id)
void (*handler)(int,void *,struct pt_regs *) 中断处理函数。
unsigned long flags 与中断管理有关的各种选项。
const char * devname 设备名
void *dev_id 对应于中断函数static irqreturn_t buttons_interrupt(int irq, void *dev_id)中的void *dev_id
• IRQF_DISABLED(SA_INTERRUPT)
如果设置该位,表示是一个“快速”中断处理程序;如果没有设置这位,那么是一个“慢速”中断处理程序。
• IRQF_SHARED(SA_SHIRQ)
该位表明中断可以在设备间共享。
快速/慢速中断:
这两种类型的中断处理程序的主要区别在于:快速中断保证中断处理的原子性(不被打断),而慢速中断则不保证。换句话说,也就是“开启中断”标志位(处理器IF)在运行快速中断处理程序时是关闭的,因此在服务该中断时,不会被其他类型的中断打断;而调用慢速中断处理时,其它类型的中断仍可以得到服务。
1. 申请共享中断时,必须在flags参数中指定IRQF_SHARED位
2. dev_id参数必须是唯一的。Q: 为什么要唯一?
中断处理程序就是普通的C代码。特别之处在于中断处理程序是在中断上下文中运行的,它的行为受到某些限制:
1. 不能向用户空间发送或接受数据
2. 不能使用可能引起阻塞的函数
3. 不能使用可能引起调度的函数
- void short_sh_interrupt(intirq, void *dev_id, struct pt_regs *regs)
- {
- /* 判断是否是本设备产生了中断(为什么要做这样的检测?) */
- value =inb(short_base);
- if (!(value& 0x80)) return;
- /* 清除中断位(如果设备支持自动清除,则不需要这步) */
- outb(value& 0x7F, short_base);
- /* 中断处理,通常是数据接收 */
- 。。。。。。。。。
- /* 唤醒等待数据的进程 */
- wake_up_interruptible(&short_queue);
- }
当设备不再需要使用中断时(通常在驱动卸载时), 应当把它们返还给系统, 使用:
- void free_irq(unsignedintirq, void*dev_id)
综合实例:
开发环境:
Cent OS 6.4、TQ2440开发板、内核版本linux-2.6.29
硬件描述:
四个按键所在端口分别为EINT1/GPF1、EINT4/GPF4、EINT2/GPF2、EINT0/GPF0
平台设备程序:
- #include <linux/module.h>
- #include <linux/types.h>
- #include <linux/fs.h>
- #include <linux/init.h>
- #include <linux/platform_device.h>
- #include <mach/regs-gpio.h>
- #include <linux/interrupt.h>
- #include <linux/device.h>
- #include <linux/io.h>
- /*平台资源的定义*/
- static struct resource s3c_buttons_resource[] = {
- [0]={
- .start = IRQ_EINT1,
- .end = IRQ_EINT1,
- .flags = IORESOURCE_IRQ,
- },
- [1]={
- .start = IRQ_EINT4,
- .end = IRQ_EINT4,
- .flags = IORESOURCE_IRQ,
- },
- [2]={
- .start = IRQ_EINT2,
- .end = IRQ_EINT2,
- .flags = IORESOURCE_IRQ,
- },
- [3]={
- .start = IRQ_EINT0,
- .end = IRQ_EINT0,
- .flags = IORESOURCE_IRQ,
- }
- };
- static struct platform_device *s3c_buttons;
- static int __init platform_init(void)
- {
- s3c_buttons = platform_device_alloc("TQ2440-buttons",-1);//名字体现在/sys/bus/platform/下的/devices/中,名字用于和device匹配
- platform_device_add_resources(s3c_buttons,&s3c_buttons_resource,4);
- /*平台设备的注册*/
- platform_device_add(s3c_buttons);
- }
- static void __exit platform_exit(void)
- {
- platform_device_unregister(s3c_buttons);
- }
- module_init(platform_init);
- module_exit(platform_exit);
- MODULE_AUTHOR("Zbffff");
- MODULE_LICENSE("GPL");
- MODULE_ALIAS("platform:tq2440buttons");
- #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/device.h> /* device_create()*/
- #include <linux/interrupt.h> /*中断所需文件*/
- #include <linux/irq.h>/*中断所需文件*/
- #include <linux/poll.h>
- #include <linux/platform_device.h>
- #include <linux/device.h>
- #include <linux/miscdevice.h>
- static struct resource *buttons_irq;
- static int button_irqs[4];
- #define DEVICE_NAME "TQ2440-buttons"
- #ifndef MEMDEV_MAJOR
- #define MEMDEV_MAJOR 252 /*预设的mem的主设备号*/
- #endif
- #ifndef MEMDEV_NR_DEVS
- #define MEMDEV_NR_DEVS 1 /*设备数*/
- #endif
- static DECLARE_WAIT_QUEUE_HEAD(button_waitq);//初始化等待队列
- static int mem_major = MEMDEV_MAJOR;
- module_param(mem_major, int, S_IRUGO);//宏module_param指定模块参数,模块参数用于在加载模块时传递参数给模块。
- struct cdev *cdevp;
- struct button_irqs_desc {
- int irq; //中断号
- unsigned long flags; //中断标志,用来定义中断的触发方式
- char *name; //中断名称
- };
- static volatile int ev_press = 0;
- /* 按键被按下的次数(准确地说,是发生中断的次数) */
- static volatile int press_cnt[] = {0,0,0,0};
- /*用来指定按键所用的外部中断引脚及中断触发方式,名字
- static struct button_irqs_desc button_irqs[] = {
- {IRQ_EINT1,IRQ_TYPE_EDGE_FALLING,"KEY1"},
- {IRQ_EINT4,IRQ_TYPE_EDGE_FALLING,"KEY2"},
- {IRQ_EINT2,IRQ_TYPE_EDGE_FALLING,"KEY3"},
- {IRQ_EINT0,IRQ_TYPE_EDGE_FALLING,"KEY4"},
- };*/
- static irqreturn_t buttons_interrupt(int irq,void *dev_id)
- {
- volatile int *press_cnt = (volatile int *)dev_id;
- *press_cnt = 1; /*按键计数器*/
- ev_press = 1; /*表示中断发生了*/
- wake_up_interruptible(&button_waitq); /*唤醒休眠的进程*/
- //printk(" IRQ:%d\n",irq);
- return IRQ_RETVAL(IRQ_HANDLED);
- }
- /*文件打开函数*/
- int mem_open(struct inode *inode, struct file *filp)
- {
- int i;
- int err;
- for(i =0;i<sizeof(button_irqs)/sizeof(button_irqs[0]);i++) {
- //注册中断处理函数
- //err = request_irq(button_irqs[i].irq,buttons_interrupt,button_irqs[i].flags,button_irqs[i].name,(void *)&press_cnt[i]);
- err = request_irq(button_irqs[i],buttons_interrupt,IRQ_TYPE_EDGE_RISING,NULL,(void *)&press_cnt[i]);
- if(err)
- break;
- }
- //如果出错,释放已经注册的中断
- if (err) {
- i--;
- for (; i >= 0; i--) {
- if (button_irqs[i] < 0) {
- continue;
- }
- disable_irq(button_irqs[i]);
- free_irq(button_irqs[i], NULL);
- }
- return -EBUSY;
- }
- ev_press = 0;
- return 0;
- }
- /*文件释放函数*/
- int mem_release(struct inode *inode, struct file *filp)
- {
- int i;
- for(i=0;i<sizeof(button_irqs)/sizeof(button_irqs[0]);i++) {
- //释放已经注册的中断
- if (button_irqs[i] < 0) {
- continue;
- }
- free_irq(button_irqs[i],(void *)&press_cnt[i]);
- }
- return 0;
- }
- /*读函数*/
- static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
- {
- unsigned long err;
- /*如果ev_press等于0,休眠*/
- //wait_event_interruptible(button_waitq,ev_press);
- /*执行到这里时ev_press肯定等于1,将它清0 */
- ev_press = 0;
- /*将按键状态复制给用户,并请0 */
- err = copy_to_user(buf,(const void *)press_cnt,sizeof(press_cnt));
- memset((void *)press_cnt,0,sizeof(press_cnt));
- return err? -EFAULT:0;
- }
- static unsigned int mem_poll( struct file *file, struct poll_table_struct *wait)
- {
- unsigned int mask = 0;
- poll_wait(file, &button_waitq, wait);
- if (ev_press){
- mask |= POLLIN | POLLRDNORM;
- }
- return mask;
- }
- /*文件操作结构体*/
- static const struct file_operations mem_fops =
- {
- .owner = THIS_MODULE,
- .read = mem_read,
- .open = mem_open,
- .poll = mem_poll,
- .release = mem_release,
- };
- static struct miscdevice tq2440_miscdev = {
- .minor = MISC_DYNAMIC_MINOR,
- .name = DEVICE_NAME,
- .fops = &mem_fops,
- };
- /* device interface */
- static int tq2440_buttons_probe(struct platform_device *pdev)
- {
- /*struct class *myclass;//用于自动创建节点文件
- int result=0;非混杂设备注册用
- int err;
- dev_t devno = MKDEV(mem_major, 0);//主次设备号合成一个数字*/
- struct device *dev;
- int ret;
- int i;
- printk("probe:%s\n", __func__);
- dev = &pdev->dev;
- /*get irq number*/
- for(i=0; i<4; i++){
- buttons_irq = platform_get_resource(pdev,IORESOURCE_IRQ,i);
- if(buttons_irq == NULL){
- dev_err(dev,"no irq resource specified\n");
- ret = -ENOENT;
- }
- button_irqs[i] = buttons_irq->start;
- //printk("button_irqs[%d]=%d\n",i,button_irqs[i]);
- }
- #if 0
- /* 静态申请设备号*/
- if (mem_major)
- result = register_chrdev_region(devno, MEMDEV_NR_DEVS, DEVICE_NAME);//memdev设备名体现在/proc/devices
- if(!mem_major||result<0) /* 动态分配设备号 */
- {
- result = alloc_chrdev_region(&devno, 0, MEMDEV_NR_DEVS, DEVICE_NAME);
- mem_major = MAJOR(devno);
- }
- if(result < 0)
- return result;
- cdevp=cdev_alloc();
- /*初始化cdev结构*/
- cdev_init(cdevp, &mem_fops);
- cdevp->owner = THIS_MODULE;
- //cdevp->ops = &mem_fops;这句不要,cdev_init已经做了
- /* 注册字符设备 */
- cdev_add(cdevp, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);
- if(IS_ERR(&err))
- printk(KERN_NOTICE "Error %d adding buttons",err);
- /*自动创建设备文件*/
- myclass = class_create(THIS_MODULE,DEVICE_NAME); /*在sys下创建类目录/sys/class/test_char*/
- device_create(myclass, NULL, MKDEV(mem_major,0), NULL, DEVICE_NAME); //体现在/dev
- //需要注意的是调试过程发现有自动创建节点文件函数的模块在一次insmod和rmmod之后再insmod会发生段错误
- #endif
- ret = misc_register(&tq2440_miscdev);
- return 0;
- }
- static int tq2440_buttons_remove(struct platform_device *dev)
- {
- #if 0
- cdev_del(cdevp); /*注销设备*/
- unregister_chrdev_region(MKDEV(mem_major, 0), MEMDEV_NR_DEVS); /*释放设备号*/
- #endif
- misc_deregister(&tq2440_miscdev);
- return 0;
- }
- /*平台驱动定义*/
- static struct platform_driver tq2440buttons_driver = {
- .probe = tq2440_buttons_probe,
- .remove = tq2440_buttons_remove,
- .driver = {
- .owner = THIS_MODULE,
- .name = DEVICE_NAME,//名字体现在/sys/bus/platform/下的/drivers/中,名字用于和device匹配
- },
- };
- static char banner[] __initdata =
- "TQ2440 Buttons Driver\n";
- /*设备驱动模块加载函数*/
- static int memdev_init(void)
- {
- printk(banner);
- platform_driver_register(&tq2440buttons_driver);
- return 0;
- }
- /*模块卸载函数*/
- static void memdev_exit(void)
- {
- platform_driver_unregister(&tq2440buttons_driver);
- }
- MODULE_AUTHOR("Zbffff");
- MODULE_DESCRIPTION("TQ2440 Buttons Driver");
- MODULE_LICENSE("GPL");
- module_init(memdev_init);
- module_exit(memdev_exit);
- #include <stdio.h>
- #include <stdlib.h>
- #include <unistd.h>
- #include <sys/ioctl.h>
- #include <errno.h>
- int main(int argc,char **argv)
- {
- int i;
- int ret;
- int fd;
- int press_cnt[4];
- fd_set rds;
- fd=open("/dev/TQ2440-buttons",0);
- if(fd<0) {
- printf("Can't open /dev/tq2440-buttons \n");
- return -1;
- }
- //这是个无限循环,进程在select函数中休眠,当有按键按下时,它才返回
- //如果被按下的次数不为0,打印出来
- for (;;) {
- FD_ZERO(&rds);
- FD_SET(fd, &rds);
- ret = select(fd + 1, &rds, NULL, NULL, NULL);
- printf("passed the poll");
- if (ret < 0) {
- perror("select");
- exit(1);
- }
- if (ret == 0) {
- printf("Timeout.\n");
- }
- else if (FD_ISSET(fd, &rds)) {
- ret = read(fd,press_cnt,sizeof(press_cnt));
- if(ret<0)printf("read error");
- else {
- for(i=0;i<sizeof(press_cnt)/sizeof(press_cnt[0]);i++){
- if(press_cnt[i])printf("Key%d has been pressed %d times \n",i+1,press_cnt[i]);
- }
- }
- }
- }
- close(fd);