段小苏学习之路
段小苏学习之路

input子系统框架分析

1. input框架介绍：

Linux input子系统主要分为三层：驱动、输入core、事件处理层。

驱动根据core提供的接口，向上报告发生的动作（input_report_**)。

core根据驱动的类型，分发这个报告给对应的事件处理层处理（input_event——>input_handle_event——>input_pass_event）

事件处理层把数据变化反应到设备模型的文件中（事件缓冲区），并通知这些设备文件上等待的进程。

驱动把输入设备注册到输入子系统，然后子系统调用匹配到的input handler的connect函数，来创建一个具体的设备结点。

一类input  handler可以和多个硬件设备相关联，创建多个设备结点（如evdev handler可以创建/dev/input/event0，/dev/input/event1）。一个设备也可以与多个input handler关联，创建多个设备结点（如触摸屏可以创建/dev/input/event2，/dev/input/ts0）。


2. input框架的主要数据结构

[cpp] view plain copy
print ?
  1. struct input_dev {  
  2.     const char *name;  
  3.     const char *phys;  
  4.     const char *uniq;  
  5.     struct input_id id; //输入设备的设备信息  
  6.   
  7.     unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];  
  8.   
  9.     unsigned long evbit[BITS_TO_LONGS(EV_CNT)]; //设备支持的事件类型  
  10.     unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];//按键事件支持的子事件  
  11.     unsigned long relbit[BITS_TO_LONGS(REL_CNT)];//相对坐标事件支持的子事件  
  12.     unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];//绝对坐标事件支持的子事件  
  13.     unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];//其它事件支持的子事件  
  14.     unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];//LED事件的子事件  
  15.     unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];//声音事件的子事件  
  16.     unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];//力反馈事件的子事件  
  17.     unsigned long swbit[BITS_TO_LONGS(SW_CNT)];//开关事件的子事件  
  18.   
  19.     unsigned int hint_events_per_packet;  
  20.   
  21.     unsigned int keycodemax;  
  22.     unsigned int keycodesize;  
  23.     void *keycode;  
  24.   
  25.     int (*setkeycode)(struct input_dev *dev,  
  26.               const struct input_keymap_entry *ke,  
  27.               unsigned int *old_keycode);  
  28.     int (*getkeycode)(struct input_dev *dev,  
  29.               struct input_keymap_entry *ke);  
  30.   
  31.     struct ff_device *ff;  
  32.   
  33.     unsigned int repeat_key;//重复按键  
  34.     struct timer_list timer;//定时器  
  35.   
  36.     int rep[REP_CNT];//重复次数  
  37.   
  38.     struct input_mt_slot *mt;  
  39.     int mtsize;  
  40.     int slot;  
  41.     int trkid;  
  42.   
  43.     struct input_absinfo *absinfo;  
  44.   
  45.     unsigned long key[BITS_TO_LONGS(KEY_CNT)];  
  46.     unsigned long led[BITS_TO_LONGS(LED_CNT)];  
  47.     unsigned long snd[BITS_TO_LONGS(SND_CNT)];  
  48.     unsigned long sw[BITS_TO_LONGS(SW_CNT)];  
  49.   
  50.     int (*open)(struct input_dev *dev);  
  51.     void (*close)(struct input_dev *dev);  
  52.     int (*flush)(struct input_dev *dev, struct file *file);  
  53.     int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);  
  54.   
  55.     struct input_handle __rcu *grab;//指向input_handle  
  56.   
  57.     spinlock_t event_lock;  
  58.     struct mutex mutex;  
  59.   
  60.     unsigned int users;  
  61.     bool going_away;  
  62.   
  63.     bool sync;  
  64.   
  65.     struct device dev;  
  66.   
  67.     struct list_head    h_list;//链表头链接该设备关联的input_handle  
  68.     struct list_head    node;//链接到全局input_dev_list  
  69. };  
  70. struct input_handle {  
  71.   
  72.     void *private;  
  73.   
  74.     int open;  
  75.     const char *name;  
  76.   
  77.     struct input_dev *dev;  //指向input_dev  
  78.     struct input_handler *handler;//指向input_handler  
  79.   
  80.     struct list_head    d_node; //通过d_node把input_handler链接到input_dev上的h_list链表头  
  81.     struct list_head    h_node;//通过h_node把input_dev链接到input_handler的h_list链表头  
  82. };  
  83. struct input_handler {  
  84.   
  85.     void *private;  
  86.     /*处理事件函数接口*/  
  87.     void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);  
  88.     bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);  
  89.     bool (*match)(struct input_handler *handler, struct input_dev *dev);  
  90.     /*建立handler和device的联系*/  
  91.     int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);  
  92.     void (*disconnect)(struct input_handle *handle);  
  93.     void (*start)(struct input_handle *handle);  
  94.   
  95.     const struct file_operations *fops;  
  96.     int minor;  
  97.     const char *name;  
  98.   
  99.     const struct input_device_id *id_table; //该handler所支持的input dev id  
  100.   
  101.     struct list_head    h_list;//链表头,指向它所支持的设备链表  
  102.     struct list_head    node;   //链接到全局input_handler_list  
  103. };  
struct input_dev {
	const char *name;
	const char *phys;
	const char *uniq;
	struct input_id id;	//输入设备的设备信息

	unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];

	unsigned long evbit[BITS_TO_LONGS(EV_CNT)];	//设备支持的事件类型
	unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];//按键事件支持的子事件
	unsigned long relbit[BITS_TO_LONGS(REL_CNT)];//相对坐标事件支持的子事件
	unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];//绝对坐标事件支持的子事件
	unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];//其它事件支持的子事件
	unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];//LED事件的子事件
	unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];//声音事件的子事件
	unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];//力反馈事件的子事件
	unsigned long swbit[BITS_TO_LONGS(SW_CNT)];//开关事件的子事件

	unsigned int hint_events_per_packet;

	unsigned int keycodemax;
	unsigned int keycodesize;
	void *keycode;

	int (*setkeycode)(struct input_dev *dev,
			  const struct input_keymap_entry *ke,
			  unsigned int *old_keycode);
	int (*getkeycode)(struct input_dev *dev,
			  struct input_keymap_entry *ke);

	struct ff_device *ff;

	unsigned int repeat_key;//重复按键
	struct timer_list timer;//定时器

	int rep[REP_CNT];//重复次数

	struct input_mt_slot *mt;
	int mtsize;
	int slot;
	int trkid;

	struct input_absinfo *absinfo;

	unsigned long key[BITS_TO_LONGS(KEY_CNT)];
	unsigned long led[BITS_TO_LONGS(LED_CNT)];
	unsigned long snd[BITS_TO_LONGS(SND_CNT)];
	unsigned long sw[BITS_TO_LONGS(SW_CNT)];

	int (*open)(struct input_dev *dev);
	void (*close)(struct input_dev *dev);
	int (*flush)(struct input_dev *dev, struct file *file);
	int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);

	struct input_handle __rcu *grab;//指向input_handle

	spinlock_t event_lock;
	struct mutex mutex;

	unsigned int users;
	bool going_away;

	bool sync;

	struct device dev;

	struct list_head	h_list;//链表头链接该设备关联的input_handle
	struct list_head	node;//链接到全局input_dev_list
};
struct input_handle {

	void *private;

	int open;
	const char *name;

	struct input_dev *dev;	//指向input_dev
	struct input_handler *handler;//指向input_handler

	struct list_head	d_node;	//通过d_node把input_handler链接到input_dev上的h_list链表头
	struct list_head	h_node;//通过h_node把input_dev链接到input_handler的h_list链表头
};
struct input_handler {

	void *private;
	/*处理事件函数接口*/
	void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
	bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
	bool (*match)(struct input_handler *handler, struct input_dev *dev);
	/*建立handler和device的联系*/
	int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
	void (*disconnect)(struct input_handle *handle);
	void (*start)(struct input_handle *handle);

	const struct file_operations *fops;
	int minor;
	const char *name;

	const struct input_device_id *id_table;	//该handler所支持的input dev id

	struct list_head	h_list;//链表头,指向它所支持的设备链表
	struct list_head	node;	//链接到全局input_handler_list
};
一个input_dev可以关联多个input_handler，每关联一个就通过input_handle的d_node把input_handler链接到input_dev中的h_list链表头，因为input_handle有一个指针指向input_handler。

一个input_handler可以关联多个input_dev，每关联一个就通过input_handle的h_node把input_dev链接到input_handler中的h_list链表头，因为input_handle有一个指针指向input_dev。


3. input  core层的API

[cpp] view plain copy
print ?
  1. int input_register_device(struct input_dev *dev)  
  2. {  
  3.     static atomic_t input_no = ATOMIC_INIT(0);  
  4.     struct input_handler *handler;  
  5.     const char *path;  
  6.     int error;  
  7.   
  8.     /* Every input device generates EV_SYN/SYN_REPORT events. */  
  9.     __set_bit(EV_SYN, dev->evbit); //每个input_dev都支持EV_SYN事件  
  10.   
  11.     /* KEY_RESERVED is not supposed to be transmitted to userspace. */  
  12.     __clear_bit(KEY_RESERVED, dev->keybit);  
  13.   
  14.     /* Make sure that bitmasks not mentioned in dev->evbit are clean. */  
  15.     input_cleanse_bitmasks(dev);  
  16.   
  17.     if (!dev->hint_events_per_packet)  
  18.         dev->hint_events_per_packet =  
  19.                 input_estimate_events_per_packet(dev);  
  20.   
  21.     /* 
  22.      * If delay and period are pre-set by the driver, then autorepeating 
  23.      * is handled by the driver itself and we don't do it in input.c. 
  24.      */  
  25.     init_timer(&dev->timer); //为处理重复击键定义的timer  
  26.     //为自动重复按键定义的  
  27.     if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {  
  28.         dev->timer.data = (long) dev;  
  29.         dev->timer.function = input_repeat_key;  
  30.         dev->rep[REP_DELAY] = 250;  
  31.         dev->rep[REP_PERIOD] = 33;  
  32.     }  
  33.     //获取键值  
  34.     if (!dev->getkeycode)  
  35.         dev->getkeycode = input_default_getkeycode;  
  36.   
  37.     if (!dev->setkeycode)  
  38.         dev->setkeycode = input_default_setkeycode;  
  39.   
  40.     dev_set_name(&dev->dev, "input%ld",  
  41.              (unsigned long) atomic_inc_return(&input_no) - 1);  
  42.     //注册到设备模型中  
  43.     error = device_add(&dev->dev);  
  44.     if (error)  
  45.         return error;  
  46.   
  47.     path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);  
  48.     pr_info("%s as %s\n",  
  49.         dev->name ? dev->name : "Unspecified device",  
  50.         path ? path : "N/A");  
  51.     kfree(path);  
  52.   
  53.     error = mutex_lock_interruptible(&input_mutex);  
  54.     if (error) {  
  55.         device_del(&dev->dev);  
  56.         return error;  
  57.     }  
  58.     //加入到全局链表  
  59.     list_add_tail(&dev->node, &input_dev_list);  
  60.     //对每一个input_handler，执行input_attach_handler  
  61.     list_for_each_entry(handler, &input_handler_list, node)  
  62.         input_attach_handler(dev, handler);  
  63.   
  64.     input_wakeup_procfs_readers();  
  65.   
  66.     mutex_unlock(&input_mutex);  
  67.   
  68.     return 0;  
  69. }  
  70. int input_register_handler(struct input_handler *handler)  
  71. {  
  72.     struct input_dev *dev;  
  73.     int retval;  
  74.   
  75.     retval = mutex_lock_interruptible(&input_mutex);  
  76.     if (retval)  
  77.         return retval;  
  78.   
  79.     INIT_LIST_HEAD(&handler->h_list);  
  80.   
  81.     if (handler->fops != NULL) {  
  82.         if (input_table[handler->minor >> 5]) {  
  83.             retval = -EBUSY;  
  84.             goto out;  
  85.         }  
  86.         input_table[handler->minor >> 5] = handler;    //以input_handler的次设备号右移5位为索引赋值给全局input_table，便于快速查找  
  87.     }  
  88.   
  89.     list_add_tail(&handler->node, &input_handler_list); //插入到全局input_handler_list链表中  
  90.   
  91.     list_for_each_entry(dev, &input_dev_list, node)  
  92.         input_attach_handler(dev, handler); //对每一个input_dev，调用input_attach_handler  
  93.   
  94.     input_wakeup_procfs_readers();  
  95.   
  96.  out:  
  97.     mutex_unlock(&input_mutex);  
  98.     return retval;  
  99. }  
  100. static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)  
  101. {  
  102.     const struct input_device_id *id;  
  103.     int error;  
  104.   
  105.     id = input_match_device(handler, dev);  //input_dev和input_handler之间的匹配  
  106.     if (!id)  
  107.         return -ENODEV;  
  108.   
  109.     error = handler->connect(handler, dev, id);  //调用input_handler的connect建立连接  
  110.     if (error && error != -ENODEV)  
  111.         pr_err("failed to attach handler %s to device %s, error: %d\n",  
  112.                handler->name, kobject_name(&dev->dev.kobj), error);  
  113.   
  114.     return error;  
  115. }  
int input_register_device(struct input_dev *dev)
{
	static atomic_t input_no = ATOMIC_INIT(0);
	struct input_handler *handler;
	const char *path;
	int error;

	/* Every input device generates EV_SYN/SYN_REPORT events. */
	__set_bit(EV_SYN, dev->evbit); //每个input_dev都支持EV_SYN事件

	/* KEY_RESERVED is not supposed to be transmitted to userspace. */
	__clear_bit(KEY_RESERVED, dev->keybit);

	/* Make sure that bitmasks not mentioned in dev->evbit are clean. */
	input_cleanse_bitmasks(dev);

	if (!dev->hint_events_per_packet)
		dev->hint_events_per_packet =
				input_estimate_events_per_packet(dev);

	/*
	 * If delay and period are pre-set by the driver, then autorepeating
	 * is handled by the driver itself and we don't do it in input.c.
	 */
	init_timer(&dev->timer); //为处理重复击键定义的timer
	//为自动重复按键定义的
	if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
		dev->timer.data = (long) dev;
		dev->timer.function = input_repeat_key;
		dev->rep[REP_DELAY] = 250;
		dev->rep[REP_PERIOD] = 33;
	}
	//获取键值
	if (!dev->getkeycode)
		dev->getkeycode = input_default_getkeycode;

	if (!dev->setkeycode)
		dev->setkeycode = input_default_setkeycode;

	dev_set_name(&dev->dev, "input%ld",
		     (unsigned long) atomic_inc_return(&input_no) - 1);
	//注册到设备模型中
	error = device_add(&dev->dev);
	if (error)
		return error;

	path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
	pr_info("%s as %s\n",
		dev->name ? dev->name : "Unspecified device",
		path ? path : "N/A");
	kfree(path);

	error = mutex_lock_interruptible(&input_mutex);
	if (error) {
		device_del(&dev->dev);
		return error;
	}
	//加入到全局链表
	list_add_tail(&dev->node, &input_dev_list);
	//对每一个input_handler，执行input_attach_handler
	list_for_each_entry(handler, &input_handler_list, node)
		input_attach_handler(dev, handler);

	input_wakeup_procfs_readers();

	mutex_unlock(&input_mutex);

	return 0;
}
int input_register_handler(struct input_handler *handler)
{
	struct input_dev *dev;
	int retval;

	retval = mutex_lock_interruptible(&input_mutex);
	if (retval)
		return retval;

	INIT_LIST_HEAD(&handler->h_list);

	if (handler->fops != NULL) {
		if (input_table[handler->minor >> 5]) {
			retval = -EBUSY;
			goto out;
		}
		input_table[handler->minor >> 5] = handler;	//以input_handler的次设备号右移5位为索引赋值给全局input_table，便于快速查找
	}

	list_add_tail(&handler->node, &input_handler_list); //插入到全局input_handler_list链表中

	list_for_each_entry(dev, &input_dev_list, node)
		input_attach_handler(dev, handler);	//对每一个input_dev，调用input_attach_handler

	input_wakeup_procfs_readers();

 out:
	mutex_unlock(&input_mutex);
	return retval;
}
static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
	const struct input_device_id *id;
	int error;

	id = input_match_device(handler, dev);	//input_dev和input_handler之间的匹配
	if (!id)
		return -ENODEV;

	error = handler->connect(handler, dev, id);	//调用input_handler的connect建立连接
	if (error && error != -ENODEV)
		pr_err("failed to attach handler %s to device %s, error: %d\n",
		       handler->name, kobject_name(&dev->dev.kobj), error);

	return error;
}
下面我们以比较常见的input_handler evdev来看下connect函数

[cpp] view plain copy
print ?
  1. static int evdev_connect(struct input_handler *handler, struct input_dev *dev,  
  2.              const struct input_device_id *id)  
  3. {  
  4.     struct evdev *evdev;    //evdev结构里面内嵌了input_handle  
  5.     int minor;  
  6.     int error;  
  7.   
  8.     for (minor = 0; minor < EVDEV_MINORS; minor++)  
  9.         if (!evdev_table[minor])  
  10.             break;  
  11.   
  12.     if (minor == EVDEV_MINORS) {  
  13.         pr_err("no more free evdev devices\n");  
  14.         return -ENFILE;  
  15.     }  
  16.   
  17.     evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);  
  18.     if (!evdev)  
  19.         return -ENOMEM;  
  20.   
  21.     INIT_LIST_HEAD(&evdev->client_list);  
  22.     spin_lock_init(&evdev->client_lock);  
  23.     mutex_init(&evdev->mutex);  
  24.     init_waitqueue_head(&evdev->wait);  
  25.   
  26.     dev_set_name(&evdev->dev, "event%d", minor);  
  27.     evdev->exist = true;  
  28.     evdev->minor = minor;  
  29.   
  30.     evdev->handle.dev = input_get_device(dev);  
  31.     evdev->handle.name = dev_name(&evdev->dev);  
  32.     evdev->handle.handler = handler;  
  33.     evdev->handle.private = evdev;  
  34.   
  35.     evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);  
  36.     evdev->dev.class = &input_class;  
  37.     evdev->dev.parent = &dev->dev;  
  38.     evdev->dev.release = evdev_free;  
  39.     device_initialize(&evdev->dev);  
  40.   
  41.     error = input_register_handle(&evdev->handle);   //注册input_handle，其实就是建立input_dev和input_handler之间关系  
  42.     if (error)  
  43.         goto err_free_evdev;  
  44.   
  45.     error = evdev_install_chrdev(evdev);  
  46.     if (error)  
  47.         goto err_unregister_handle;  
  48.   
  49.     error = device_add(&evdev->dev); //注册到设备模型中  
  50.     if (error)  
  51.         goto err_cleanup_evdev;  
  52.   
  53.     return 0;  
  54.   
  55.  err_cleanup_evdev:  
  56.     evdev_cleanup(evdev);  
  57.  err_unregister_handle:  
  58.     input_unregister_handle(&evdev->handle);  
  59.  err_free_evdev:  
  60.     put_device(&evdev->dev);  
  61.     return error;  
  62. }  
  63. int input_register_handle(struct input_handle *handle)  
  64. {  
  65.     struct input_handler *handler = handle->handler;  
  66.     struct input_dev *dev = handle->dev;  
  67.     int error;  
  68.   
  69.     /* 
  70.      * We take dev->mutex here to prevent race with 
  71.      * input_release_device(). 
  72.      */  
  73.     error = mutex_lock_interruptible(&dev->mutex);  
  74.     if (error)  
  75.         return error;  
  76.   
  77.     /* 
  78.      * Filters go to the head of the list, normal handlers 
  79.      * to the tail. 
  80.      */  
  81.     if (handler->filter)  
  82.         list_add_rcu(&handle->d_node, &dev->h_list);  
  83.     else  
  84.         list_add_tail_rcu(&handle->d_node, &dev->h_list);  
  85.   
  86.     mutex_unlock(&dev->mutex);  
  87.   
  88.     /* 
  89.      * Since we are supposed to be called from ->connect() 
  90.      * which is mutually exclusive with ->disconnect() 
  91.      * we can't be racing with input_unregister_handle() 
  92.      * and so separate lock is not needed here. 
  93.      */  
  94.     list_add_tail_rcu(&handle->h_node, &handler->h_list);  
  95.   
  96.     if (handler->start)  
  97.         handler->start(handle);  
  98.   
  99.     return 0;  
  100. }  
static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
			 const struct input_device_id *id)
{
	struct evdev *evdev;	//evdev结构里面内嵌了input_handle
	int minor;
	int error;

	for (minor = 0; minor < EVDEV_MINORS; minor++)
		if (!evdev_table[minor])
			break;

	if (minor == EVDEV_MINORS) {
		pr_err("no more free evdev devices\n");
		return -ENFILE;
	}

	evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
	if (!evdev)
		return -ENOMEM;

	INIT_LIST_HEAD(&evdev->client_list);
	spin_lock_init(&evdev->client_lock);
	mutex_init(&evdev->mutex);
	init_waitqueue_head(&evdev->wait);

	dev_set_name(&evdev->dev, "event%d", minor);
	evdev->exist = true;
	evdev->minor = minor;

	evdev->handle.dev = input_get_device(dev);
	evdev->handle.name = dev_name(&evdev->dev);
	evdev->handle.handler = handler;
	evdev->handle.private = evdev;

	evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
	evdev->dev.class = &input_class;
	evdev->dev.parent = &dev->dev;
	evdev->dev.release = evdev_free;
	device_initialize(&evdev->dev);

	error = input_register_handle(&evdev->handle);	//注册input_handle，其实就是建立input_dev和input_handler之间关系
	if (error)
		goto err_free_evdev;

	error = evdev_install_chrdev(evdev);
	if (error)
		goto err_unregister_handle;

	error = device_add(&evdev->dev);	//注册到设备模型中
	if (error)
		goto err_cleanup_evdev;

	return 0;

 err_cleanup_evdev:
	evdev_cleanup(evdev);
 err_unregister_handle:
	input_unregister_handle(&evdev->handle);
 err_free_evdev:
	put_device(&evdev->dev);
	return error;
}
int input_register_handle(struct input_handle *handle)
{
	struct input_handler *handler = handle->handler;
	struct input_dev *dev = handle->dev;
	int error;

	/*
	 * We take dev->mutex here to prevent race with
	 * input_release_device().
	 */
	error = mutex_lock_interruptible(&dev->mutex);
	if (error)
		return error;

	/*
	 * Filters go to the head of the list, normal handlers
	 * to the tail.
	 */
	if (handler->filter)
		list_add_rcu(&handle->d_node, &dev->h_list);
	else
		list_add_tail_rcu(&handle->d_node, &dev->h_list);

	mutex_unlock(&dev->mutex);

	/*
	 * Since we are supposed to be called from ->connect()
	 * which is mutually exclusive with ->disconnect()
	 * we can't be racing with input_unregister_handle()
	 * and so separate lock is not needed here.
	 */
	list_add_tail_rcu(&handle->h_node, &handler->h_list);

	if (handler->start)
		handler->start(handle);

	return 0;
}

 上面是这些数据结构的建立，以及它们之间关系建立的分析。下面分析下事件传递的过程。input_report_xxx都是调用input_event函数。 
   
 
    
 
     
 [cpp] view plain copy 
      
 
      
 print ? 
     
 
    
 
    
     
     
  1. void input_event(struct input_dev *dev,  
    2.  
     
  2.          unsigned int type, unsigned int code, int value)  
    3.  
     
  3. {  
    4.  
     
  4.     unsigned long flags;  
    5.  
     
  5.   
    6.  
     
  6.     if (is_event_supported(type, dev->evbit, EV_MAX)) {  
    7.  
     
  7.   
    8.  
     
  8.         spin_lock_irqsave(&dev->event_lock, flags);  
    9.  
     
  9.         add_input_randomness(type, code, value);  
    10.  
     
  10.         input_handle_event(dev, type, code, value); //直接调用input_handle_event  
    11.  
     
  11.         spin_unlock_irqrestore(&dev->event_lock, flags);  
    12.  
     
  12.     }  
    13.  
     
  13. }  
    14.  
     
  14. static void input_handle_event(struct input_dev *dev,  
    15.  
     
  15.                    unsigned int type, unsigned int code, int value)  
    16.  
     
  16. {  
    17.  
     
  17.     int disposition = INPUT_IGNORE_EVENT;  
    18.  
     
  18.   
    19.  
     
  19.     switch (type) {  
    20.  
     
  20.   
    21.  
     
  21.     case EV_SYN:  
    22.  
     
  22.         switch (code) {  
    23.  
     
  23.         case SYN_CONFIG:  
    24.  
     
  24.             disposition = INPUT_PASS_TO_ALL;  
    25.  
     
  25.             break;  
    26.  
     
  26.   
    27.  
     
  27.         case SYN_REPORT:  
    28.  
     
  28.             if (!dev->sync) {  
    29.  
     
  29.                 dev->sync = true;  
    30.  
     
  30.                 disposition = INPUT_PASS_TO_HANDLERS;  
    31.  
     
  31.             }  
    32.  
     
  32.             break;  
    33.  
     
  33.         case SYN_MT_REPORT:  
    34.  
     
  34.             dev->sync = false;  
    35.  
     
  35.             disposition = INPUT_PASS_TO_HANDLERS;  
    36.  
     
  36.             break;  
    37.  
     
  37.         }  
    38.  
     
  38.         break;  
    39.  
     
  39.   
    40.  
     
  40.     case EV_KEY:  
    41.  
     
  41.         if (is_event_supported(code, dev->keybit, KEY_MAX) &&  
    42.  
     
  42.             !!test_bit(code, dev->key) != value) {  
    43.  
     
  43.   
    44.  
     
  44.             if (value != 2) {  
    45.  
     
  45.                 __change_bit(code, dev->key);  
    46.  
     
  46.                 if (value)  
    47.  
     
  47.                     input_start_autorepeat(dev, code);  
    48.  
     
  48.                 else  
    49.  
     
  49.                     input_stop_autorepeat(dev);  
    50.  
     
  50.             }  
    51.  
     
  51.   
    52.  
     
  52.             disposition = INPUT_PASS_TO_HANDLERS;  
    53.  
     
  53.         }  
    54.  
     
  54.         break;  
    55.  
     
  55.   
    56.  
     
  56.     case EV_SW:  
    57.  
     
  57.         if (is_event_supported(code, dev->swbit, SW_MAX) &&  
    58.  
     
  58.             !!test_bit(code, dev->sw) != value) {  
    59.  
     
  59.   
    60.  
     
  60.             __change_bit(code, dev->sw);  
    61.  
     
  61.             disposition = INPUT_PASS_TO_HANDLERS;  
    62.  
     
  62.         }  
    63.  
     
  63.         break;  
    64.  
     
  64.   
    65.  
     
  65.     case EV_ABS:  
    66.  
     
  66.         if (is_event_supported(code, dev->absbit, ABS_MAX))  
    67.  
     
  67.             disposition = input_handle_abs_event(dev, code, &value);  
    68.  
     
  68.   
    69.  
     
  69.         break;  
    70.  
     
  70.   
    71.  
     
  71.     case EV_REL:  
    72.  
     
  72.         if (is_event_supported(code, dev->relbit, REL_MAX) && value)  
    73.  
     
  73.             disposition = INPUT_PASS_TO_HANDLERS;  
    74.  
     
  74.   
    75.  
     
  75.         break;  
    76.  
     
  76.   
    77.  
     
  77.     case EV_MSC:  
    78.  
     
  78.         if (is_event_supported(code, dev->mscbit, MSC_MAX))  
    79.  
     
  79.             disposition = INPUT_PASS_TO_ALL;  
    80.  
     
  80.   
    81.  
     
  81.         break;  
    82.  
     
  82.   
    83.  
     
  83.     case EV_LED:  
    84.  
     
  84.         if (is_event_supported(code, dev->ledbit, LED_MAX) &&  
    85.  
     
  85.             !!test_bit(code, dev->led) != value) {  
    86.  
     
  86.   
    87.  
     
  87.             __change_bit(code, dev->led);  
    88.  
     
  88.             disposition = INPUT_PASS_TO_ALL;  
    89.  
     
  89.         }  
    90.  
     
  90.         break;  
    91.  
     
  91.   
    92.  
     
  92.     case EV_SND:  
    93.  
     
  93.         if (is_event_supported(code, dev->sndbit, SND_MAX)) {  
    94.  
     
  94.   
    95.  
     
  95.             if (!!test_bit(code, dev->snd) != !!value)  
    96.  
     
  96.                 __change_bit(code, dev->snd);  
    97.  
     
  97.             disposition = INPUT_PASS_TO_ALL;  
    98.  
     
  98.         }  
    99.  
     
  99.         break;  
    100.  
     
  100.   
    101.  
     
  101.     case EV_REP:  
    102.  
     
  102.         if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {  
    103.  
     
  103.             dev->rep[code] = value;  
    104.  
     
  104.             disposition = INPUT_PASS_TO_ALL;  
    105.  
     
  105.         }  
    106.  
     
  106.         break;  
    107.  
     
  107.   
    108.  
     
  108.     case EV_FF:  
    109.  
     
  109.         if (value >= 0)  
    110.  
     
  110.             disposition = INPUT_PASS_TO_ALL;  
    111.  
     
  111.         break;  
    112.  
     
  112.   
    113.  
     
  113.     case EV_PWR:  
    114.  
     
  114.         disposition = INPUT_PASS_TO_ALL;  
    115.  
     
  115.         break;  
    116.  
     
  116.     }  
    117.  
     
  117.   
    118.  
     
  118.     if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)  
    119.  
     
  119.         dev->sync = false;  
    120.  
     
  120.   
    121.  
     
  121.     if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)  
    122.  
     
  122.         dev->event(dev, type, code, value);  
    123.  
     
  123.   
    124.  
     
  124.     if (disposition & INPUT_PASS_TO_HANDLERS) //如果需要处理，调用input_pass_event  
    125.  
     
  125.         input_pass_event(dev, type, code, value);  
    126.  
     
  126. }  
    127.  
     
  127. static void input_pass_event(struct input_dev *dev,  
    128.  
     
  128.                  unsigned int type, unsigned int code, int value)  
    129.  
     
  129. {  
    130.  
     
  130.     struct input_handler *handler;  
    131.  
     
  131.     struct input_handle *handle;  
    132.  
     
  132.   
    133.  
     
  133.     rcu_read_lock();  
    134.  
     
  134.   
    135.  
     
  135.     handle = rcu_dereference(dev->grab); //强制为dev赋的handler  
    136.  
     
  136.     if (handle)  
    137.  
     
  137.         handle->handler->event(handle, type, code, value);  
    138.  
     
  138.     else {  
    139.  
     
  139.         bool filtered = false;  
    140.  
     
  140.         //如果没有为grab赋值，就会遍历该dev的handle链表  
    141.  
     
  141.         list_for_each_entry_rcu(handle, &dev->h_list, d_node) {  
    142.  
     
  142.             if (!handle->open)  
    143.  
     
  143.                 continue;  
    144.  
     
  144.             //如果handle打开，表示该设备已经被一个用户进程使用  
    145.  
     
  145.             handler = handle->handler;  
    146.  
     
  146.             if (!handler->filter) {  
    147.  
     
  147.                 if (filtered)  
    148.  
     
  148.                     break;  
    149.  
     
  149.   
    150.  
     
  150.                 handler->event(handle, type, code, value); //调用event函数  
    151.  
     
  151.   
    152.  
     
  152.             } else if (handler->filter(handle, type, code, value))  
    153.  
     
  153.                 filtered = true;  
    154.  
     
  154.         }  
    155.  
     
  155.     }  
    156.  
     
  156.   
    157.  
     
  157.     rcu_read_unlock();  
    158.  
     
  158. }  
    159.  
    
 
    
  
    
 
   
 
   
void input_event(struct input_dev *dev,
		 unsigned int type, unsigned int code, int value)
{
	unsigned long flags;

	if (is_event_supported(type, dev->evbit, EV_MAX)) {

		spin_lock_irqsave(&dev->event_lock, flags);
		add_input_randomness(type, code, value);
		input_handle_event(dev, type, code, value);	//直接调用input_handle_event
		spin_unlock_irqrestore(&dev->event_lock, flags);
	}
}
static void input_handle_event(struct input_dev *dev,
			       unsigned int type, unsigned int code, int value)
{
	int disposition = INPUT_IGNORE_EVENT;

	switch (type) {

	case EV_SYN:
		switch (code) {
		case SYN_CONFIG:
			disposition = INPUT_PASS_TO_ALL;
			break;

		case SYN_REPORT:
			if (!dev->sync) {
				dev->sync = true;
				disposition = INPUT_PASS_TO_HANDLERS;
			}
			break;
		case SYN_MT_REPORT:
			dev->sync = false;
			disposition = INPUT_PASS_TO_HANDLERS;
			break;
		}
		break;

	case EV_KEY:
		if (is_event_supported(code, dev->keybit, KEY_MAX) &&
		    !!test_bit(code, dev->key) != value) {

			if (value != 2) {
				__change_bit(code, dev->key);
				if (value)
					input_start_autorepeat(dev, code);
				else
					input_stop_autorepeat(dev);
			}

			disposition = INPUT_PASS_TO_HANDLERS;
		}
		break;

	case EV_SW:
		if (is_event_supported(code, dev->swbit, SW_MAX) &&
		    !!test_bit(code, dev->sw) != value) {

			__change_bit(code, dev->sw);
			disposition = INPUT_PASS_TO_HANDLERS;
		}
		break;

	case EV_ABS:
		if (is_event_supported(code, dev->absbit, ABS_MAX))
			disposition = input_handle_abs_event(dev, code, &value);

		break;

	case EV_REL:
		if (is_event_supported(code, dev->relbit, REL_MAX) && value)
			disposition = INPUT_PASS_TO_HANDLERS;

		break;

	case EV_MSC:
		if (is_event_supported(code, dev->mscbit, MSC_MAX))
			disposition = INPUT_PASS_TO_ALL;

		break;

	case EV_LED:
		if (is_event_supported(code, dev->ledbit, LED_MAX) &&
		    !!test_bit(code, dev->led) != value) {

			__change_bit(code, dev->led);
			disposition = INPUT_PASS_TO_ALL;
		}
		break;

	case EV_SND:
		if (is_event_supported(code, dev->sndbit, SND_MAX)) {

			if (!!test_bit(code, dev->snd) != !!value)
				__change_bit(code, dev->snd);
			disposition = INPUT_PASS_TO_ALL;
		}
		break;

	case EV_REP:
		if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
			dev->rep[code] = value;
			disposition = INPUT_PASS_TO_ALL;
		}
		break;

	case EV_FF:
		if (value >= 0)
			disposition = INPUT_PASS_TO_ALL;
		break;

	case EV_PWR:
		disposition = INPUT_PASS_TO_ALL;
		break;
	}

	if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
		dev->sync = false;

	if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
		dev->event(dev, type, code, value);

	if (disposition & INPUT_PASS_TO_HANDLERS) //如果需要处理，调用input_pass_event
		input_pass_event(dev, type, code, value);
}
static void input_pass_event(struct input_dev *dev,
			     unsigned int type, unsigned int code, int value)
{
	struct input_handler *handler;
	struct input_handle *handle;

	rcu_read_lock();

	handle = rcu_dereference(dev->grab);	//强制为dev赋的handler
	if (handle)
		handle->handler->event(handle, type, code, value);
	else {
		bool filtered = false;
		//如果没有为grab赋值，就会遍历该dev的handle链表
		list_for_each_entry_rcu(handle, &dev->h_list, d_node) {
			if (!handle->open)
				continue;
			//如果handle打开，表示该设备已经被一个用户进程使用
			handler = handle->handler;
			if (!handler->filter) {
				if (filtered)
					break;

				handler->event(handle, type, code, value); //调用event函数

			} else if (handler->filter(handle, type, code, value))
				filtered = true;
		}
	}

	rcu_read_unlock();
}


4. input  handler例子evdev的分析 
   
 
   
 
   
 
    
 
     
 [cpp] view plain copy 
      
 
      
 print ? 
     
 
    
 
    
     
     
  1. static int __init evdev_init(void)  
    2.  
     
  2. {  
    3.  
     
  3.     return input_register_handler(&evdev_handler);  
    4.  
     
  4. }  
    5.  
     
  5. static struct input_handler evdev_handler = {  
    6.  
     
  6.     .event      = evdev_event,  
    7.  
     
  7.     .connect    = evdev_connect,  
    8.  
     
  8.     .disconnect = evdev_disconnect,  
    9.  
     
  9.     .fops       = &evdev_fops,  
    10.  
     
  10.     .minor      = EVDEV_MINOR_BASE,  
    11.  
     
  11.     .name       = "evdev",  
    12.  
     
  12.     .id_table   = evdev_ids,  
    13.  
     
  13. };  
    14.  
     
  14. static const struct file_operations evdev_fops = {  
    15.  
     
  15.     .owner      = THIS_MODULE,  
    16.  
     
  16.     .read       = evdev_read,  
    17.  
     
  17.     .write      = evdev_write,  
    18.  
     
  18.     .poll       = evdev_poll,  
    19.  
     
  19.     .open       = evdev_open,  
    20.  
     
  20.     .release    = evdev_release,  
    21.  
     
  21.     .unlocked_ioctl = evdev_ioctl,  
    22.  
     
  22. #ifdef CONFIG_COMPAT  
    23.  
     
  23.     .compat_ioctl   = evdev_ioctl_compat,  
    24.  
     
  24. #endif  
    25.  
     
  25.     .fasync     = evdev_fasync,  
    26.  
     
  26.     .flush      = evdev_flush,  
    27.  
     
  27.     .llseek     = no_llseek,  
    28.  
     
  28. };  
    29.  
    
 
    
  
    
 
   
 
   
static int __init evdev_init(void)
{
	return input_register_handler(&evdev_handler);
}
static struct input_handler evdev_handler = {
	.event		= evdev_event,
	.connect	= evdev_connect,
	.disconnect	= evdev_disconnect,
	.fops		= &evdev_fops,
	.minor		= EVDEV_MINOR_BASE,
	.name		= "evdev",
	.id_table	= evdev_ids,
};
static const struct file_operations evdev_fops = {
	.owner		= THIS_MODULE,
	.read		= evdev_read,
	.write		= evdev_write,
	.poll		= evdev_poll,
	.open		= evdev_open,
	.release	= evdev_release,
	.unlocked_ioctl	= evdev_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= evdev_ioctl_compat,
#endif
	.fasync		= evdev_fasync,
	.flush		= evdev_flush,
	.llseek		= no_llseek,
};

evdev的数据结构 
   
 
   
 
   
 
    
 
     
 [cpp] view plain copy 
      
 
      
 print ? 
     
 
    
 
    
     
     
  1. struct evdev {  
    2.  
     
  2.     int open;  
    3.  
     
  3.     int minor;  
    4.  
     
  4.     struct input_handle handle; //所属的input_handler  
    5.  
     
  5.     wait_queue_head_t wait; //等待队列头  
    6.  
     
  6.     struct evdev_client __rcu *grab;  
    7.  
     
  7.     struct list_head client_list;   //evdev_client链表头  
    8.  
     
  8.     spinlock_t client_lock; /* protects client_list */  
    9.  
     
  9.     struct mutex mutex;  
    10.  
     
  10.     struct device dev;  
    11.  
     
  11.     bool exist;  
    12.  
     
  12. };  
    13.  
     
  13. struct evdev_client {  
    14.  
     
  14.     unsigned int head;  //针对buffer的索引  
    15.  
     
  15.     unsigned int tail;  //针对buffer的索引  
    16.  
     
  16.     unsigned int packet_head; /* [future] position of the first element of next packet */  
    17.  
     
  17.     spinlock_t buffer_lock; /* protects access to buffer, head and tail */  
    18.  
     
  18.     struct fasync_struct *fasync;   //异步通知  
    19.  
     
  19.     struct evdev *evdev;    //evdev设备  
    20.  
     
  20.     struct list_head node;  //evdev_client链表项  
    21.  
     
  21.     unsigned int bufsize;  
    22.  
     
  22.     struct input_event buffer[]; //事件缓冲  
    23.  
     
  23. };  
    24.  
    
 
    
  
    
 
   
 
   
struct evdev {
	int open;
	int minor;
	struct input_handle handle;	//所属的input_handler
	wait_queue_head_t wait;	//等待队列头
	struct evdev_client __rcu *grab;
	struct list_head client_list;	//evdev_client链表头
	spinlock_t client_lock; /* protects client_list */
	struct mutex mutex;
	struct device dev;
	bool exist;
};
struct evdev_client {
	unsigned int head;	//针对buffer的索引
	unsigned int tail;	//针对buffer的索引
	unsigned int packet_head; /* [future] position of the first element of next packet */
	spinlock_t buffer_lock; /* protects access to buffer, head and tail */
	struct fasync_struct *fasync;	//异步通知
	struct evdev *evdev;	//evdev设备
	struct list_head node;	//evdev_client链表项
	unsigned int bufsize;
	struct input_event buffer[]; //事件缓冲
};
evdev设备结点的（/dev/input/event0)的打开 
   
 
   
对主设备号为INPUT_MAJOR的设备节点进行操作，会转换为对input_handler的操作。该过程在input_open_file中。直接看evdev_open
 
   
 
   
 
    
 
     
 [cpp] view plain copy 
      
 
      
 print ? 
     
 
    
 
    
     
     
  1. static int evdev_open(struct inode *inode, struct file *file)  
    2.  
     
  2. {  
    3.  
     
  3.     struct evdev *evdev;  
    4.  
     
  4.     struct evdev_client *client;  
    5.  
     
  5.     int i = iminor(inode) - EVDEV_MINOR_BASE;  
    6.  
     
  6.     unsigned int bufsize;  
    7.  
     
  7.     int error;  
    8.  
     
  8.   
    9.  
     
  9.     if (i >= EVDEV_MINORS)  
    10.  
     
  10.         return -ENODEV;  
    11.  
     
  11.   
    12.  
     
  12.     error = mutex_lock_interruptible(&evdev_table_mutex);  
    13.  
     
  13.     if (error)  
    14.  
     
  14.         return error;  
    15.  
     
  15.     evdev = evdev_table[i];  
    16.  
     
  16.     if (evdev)  
    17.  
     
  17.         get_device(&evdev->dev);  
    18.  
     
  18.     mutex_unlock(&evdev_table_mutex);  
    19.  
     
  19.   
    20.  
     
  20.     if (!evdev)  
    21.  
     
  21.         return -ENODEV;  
    22.  
     
  22.   
    23.  
     
  23.     bufsize = evdev_compute_buffer_size(evdev->handle.dev);  
    24.  
     
  24.     //分配evdev_client和事件缓冲  
    25.  
     
  25.     client = kzalloc(sizeof(struct evdev_client) +  
    26.  
     
  26.                 bufsize * sizeof(struct input_event),  
    27.  
     
  27.              GFP_KERNEL);  
    28.  
     
  28.     if (!client) {  
    29.  
     
  29.         error = -ENOMEM;  
    30.  
     
  30.         goto err_put_evdev;  
    31.  
     
  31.     }  
    32.  
     
  32.   
    33.  
     
  33.     client->bufsize = bufsize;  
    34.  
     
  34.     spin_lock_init(&client->buffer_lock);  
    35.  
     
  35.     client->evdev = evdev;  
    36.  
     
  36.     evdev_attach_client(evdev, client);  
    37.  
     
  37.   
    38.  
     
  38.     error = evdev_open_device(evdev); //调用真正的底层设备函数  
    39.  
     
  39.     if (error)  
    40.  
     
  40.         goto err_free_client;  
    41.  
     
  41.   
    42.  
     
  42.     file->private_data = client;  
    43.  
     
  43.     nonseekable_open(inode, file);  
    44.  
     
  44.   
    45.  
     
  45.     return 0;  
    46.  
     
  46.   
    47.  
     
  47.  err_free_client:  
    48.  
     
  48.     evdev_detach_client(evdev, client);  
    49.  
     
  49.     kfree(client);  
    50.  
     
  50.  err_put_evdev:  
    51.  
     
  51.     put_device(&evdev->dev);  
    52.  
     
  52.     return error;  
    53.  
     
  53. }  
    54.  
     
  54. static int evdev_open_device(struct evdev *evdev)  
    55.  
     
  55. {  
    56.  
     
  56.     int retval;  
    57.  
     
  57.   
    58.  
     
  58.     retval = mutex_lock_interruptible(&evdev->mutex);  
    59.  
     
  59.     if (retval)  
    60.  
     
  60.         return retval;  
    61.  
     
  61.   
    62.  
     
  62.     if (!evdev->exist)  
    63.  
     
  63.         retval = -ENODEV;  
    64.  
     
  64.     else if (!evdev->open++) {  
    65.  
     
  65.         retval = input_open_device(&evdev->handle); //第一次打开，调用input_open_device  
    66.  
     
  66.         if (retval)  
    67.  
     
  67.             evdev->open--;  
    68.  
     
  68.     }  
    69.  
     
  69.   
    70.  
     
  70.     mutex_unlock(&evdev->mutex);  
    71.  
     
  71.     return retval;  
    72.  
     
  72. }  
    73.  
     
  73. int input_open_device(struct input_handle *handle)  
    74.  
     
  74. {  
    75.  
     
  75.     struct input_dev *dev = handle->dev;  
    76.  
     
  76.     int retval;  
    77.  
     
  77.   
    78.  
     
  78.     retval = mutex_lock_interruptible(&dev->mutex);  
    79.  
     
  79.     if (retval)  
    80.  
     
  80.         return retval;  
    81.  
     
  81.   
    82.  
     
  82.     if (dev->going_away) {  
    83.  
     
  83.         retval = -ENODEV;  
    84.  
     
  84.         goto out;  
    85.  
     
  85.     }  
    86.  
     
  86.   
    87.  
     
  87.     handle->open++;  //递增handle的打开计数  
    88.  
     
  88.   
    89.  
     
  89.     if (!dev->users++ && dev->open)  
    90.  
     
  90.         retval = dev->open(dev); //如果是第一次打开，调用input_dev的open函数  
    91.  
     
  91.   
    92.  
     
  92.     if (retval) {  
    93.  
     
  93.         dev->users--;  
    94.  
     
  94.         if (!--handle->open) {  
    95.  
     
  95.             /* 
    96.  
     
  96.              * Make sure we are not delivering any more events 
    97.  
     
  97.              * through this handle 
    98.  
     
  98.              */  
    99.  
     
  99.             synchronize_rcu();  
    100.  
     
  100.         }  
    101.  
     
  101.     }  
    102.  
     
  102.   
    103.  
     
  103.  out:  
    104.  
     
  104.     mutex_unlock(&dev->mutex);  
    105.  
     
  105.     return retval;  
    106.  
     
  106. }  
    107.  
    
 
    
  
    
 
   
 
   
static int evdev_open(struct inode *inode, struct file *file)
{
	struct evdev *evdev;
	struct evdev_client *client;
	int i = iminor(inode) - EVDEV_MINOR_BASE;
	unsigned int bufsize;
	int error;

	if (i >= EVDEV_MINORS)
		return -ENODEV;

	error = mutex_lock_interruptible(&evdev_table_mutex);
	if (error)
		return error;
	evdev = evdev_table[i];
	if (evdev)
		get_device(&evdev->dev);
	mutex_unlock(&evdev_table_mutex);

	if (!evdev)
		return -ENODEV;

	bufsize = evdev_compute_buffer_size(evdev->handle.dev);
	//分配evdev_client和事件缓冲
	client = kzalloc(sizeof(struct evdev_client) +
				bufsize * sizeof(struct input_event),
			 GFP_KERNEL);
	if (!client) {
		error = -ENOMEM;
		goto err_put_evdev;
	}

	client->bufsize = bufsize;
	spin_lock_init(&client->buffer_lock);
	client->evdev = evdev;
	evdev_attach_client(evdev, client);

	error = evdev_open_device(evdev); //调用真正的底层设备函数
	if (error)
		goto err_free_client;

	file->private_data = client;
	nonseekable_open(inode, file);

	return 0;

 err_free_client:
	evdev_detach_client(evdev, client);
	kfree(client);
 err_put_evdev:
	put_device(&evdev->dev);
	return error;
}
static int evdev_open_device(struct evdev *evdev)
{
	int retval;

	retval = mutex_lock_interruptible(&evdev->mutex);
	if (retval)
		return retval;

	if (!evdev->exist)
		retval = -ENODEV;
	else if (!evdev->open++) {
		retval = input_open_device(&evdev->handle); //第一次打开，调用input_open_device
		if (retval)
			evdev->open--;
	}

	mutex_unlock(&evdev->mutex);
	return retval;
}
int input_open_device(struct input_handle *handle)
{
	struct input_dev *dev = handle->dev;
	int retval;

	retval = mutex_lock_interruptible(&dev->mutex);
	if (retval)
		return retval;

	if (dev->going_away) {
		retval = -ENODEV;
		goto out;
	}

	handle->open++;	//递增handle的打开计数

	if (!dev->users++ && dev->open)
		retval = dev->open(dev);	//如果是第一次打开，调用input_dev的open函数

	if (retval) {
		dev->users--;
		if (!--handle->open) {
			/*
			 * Make sure we are not delivering any more events
			 * through this handle
			 */
			synchronize_rcu();
		}
	}

 out:
	mutex_unlock(&dev->mutex);
	return retval;
}
 
   
可以看到open操作，先是在input core层，再进入input handler层，后面又进入input core层，最后进入input dev的驱动层。内核中这种偷梁换柱的操作很多。
 
   
再来看下evdev_event
 
   
 
   
 
    
 
     
 [cpp] view plain copy 
      
 
      
 print ? 
     
 
    
 
    
     
     
  1. static void evdev_event(struct input_handle *handle,  
    2.  
     
  2.             unsigned int type, unsigned int code, int value)  
    3.  
     
  3. {  
    4.  
     
  4.     struct evdev *evdev = handle->private;  
    5.  
     
  5.     struct evdev_client *client;  
    6.  
     
  6.     struct input_event event;  
    7.  
     
  7.   
    8.  
     
  8.     do_gettimeofday(&event.time);  
    9.  
     
  9.     event.type = type;  
    10.  
     
  10.     event.code = code;  
    11.  
     
  11.     event.value = value;  
    12.  
     
  12.   
    13.  
     
  13.     rcu_read_lock();  
    14.  
     
  14.   
    15.  
     
  15.     client = rcu_dereference(evdev->grab);  
    16.  
     
  16.     if (client)  
    17.  
     
  17.         evdev_pass_event(client, &event);  
    18.  
     
  18.     else  
    19.  
     
  19.         //遍历client链表，调用evdev_pass_event  
    20.  
     
  20.         list_for_each_entry_rcu(client, &evdev->client_list, node)  
    21.  
     
  21.             evdev_pass_event(client, &event);  
    22.  
     
  22.   
    23.  
     
  23.     rcu_read_unlock();  
    24.  
     
  24.   
    25.  
     
  25.     if (type == EV_SYN && code == SYN_REPORT)  
    26.  
     
  26.         wake_up_interruptible(&evdev->wait);  
    27.  
     
  27. }  
    28.  
     
  28. static void evdev_pass_event(struct evdev_client *client,  
    29.  
     
  29.                  struct input_event *event)  
    30.  
     
  30. {  
    31.  
     
  31.     /* Interrupts are disabled, just acquire the lock. */  
    32.  
     
  32.     spin_lock(&client->buffer_lock);  
    33.  
     
  33.   
    34.  
     
  34.     client->buffer[client->head++] = *event;  
    35.  
     
  35.     client->head &= client->bufsize - 1;  
    36.  
     
  36.   
    37.  
     
  37.     if (unlikely(client->head == client->tail)) {  
    38.  
     
  38.         /* 
    39.  
     
  39.          * This effectively "drops" all unconsumed events, leaving 
    40.  
     
  40.          * EV_SYN/SYN_DROPPED plus the newest event in the queue. 
    41.  
     
  41.          */  
    42.  
     
  42.         client->tail = (client->head - 2) & (client->bufsize - 1);  
    43.  
     
  43.   
    44.  
     
  44.         client->buffer[client->tail].time = event->time;  
    45.  
     
  45.         client->buffer[client->tail].type = EV_SYN;  
    46.  
     
  46.         client->buffer[client->tail].code = SYN_DROPPED;  
    47.  
     
  47.         client->buffer[client->tail].value = 0;  
    48.  
     
  48.   
    49.  
     
  49.         client->packet_head = client->tail;  
    50.  
     
  50.     }  
    51.  
     
  51.   
    52.  
     
  52.     if (event->type == EV_SYN && event->code == SYN_REPORT) {  
    53.  
     
  53.         client->packet_head = client->head;  
    54.  
     
  54.         kill_fasync(&client->fasync, SIGIO, POLL_IN);  
    55.  
     
  55.     }  
    56.  
     
  56.   
    57.  
     
  57.     spin_unlock(&client->buffer_lock);  
    58.  
     
  58. }  
    59.  
    
 
    
  
    
 
   
 
   
static void evdev_event(struct input_handle *handle,
			unsigned int type, unsigned int code, int value)
{
	struct evdev *evdev = handle->private;
	struct evdev_client *client;
	struct input_event event;

	do_gettimeofday(&event.time);
	event.type = type;
	event.code = code;
	event.value = value;

	rcu_read_lock();

	client = rcu_dereference(evdev->grab);
	if (client)
		evdev_pass_event(client, &event);
	else
		//遍历client链表，调用evdev_pass_event
		list_for_each_entry_rcu(client, &evdev->client_list, node)
			evdev_pass_event(client, &event);

	rcu_read_unlock();

	if (type == EV_SYN && code == SYN_REPORT)
		wake_up_interruptible(&evdev->wait);
}
static void evdev_pass_event(struct evdev_client *client,
			     struct input_event *event)
{
	/* Interrupts are disabled, just acquire the lock. */
	spin_lock(&client->buffer_lock);

	client->buffer[client->head++] = *event;
	client->head &= client->bufsize - 1;

	if (unlikely(client->head == client->tail)) {
		/*
		 * This effectively "drops" all unconsumed events, leaving
		 * EV_SYN/SYN_DROPPED plus the newest event in the queue.
		 */
		client->tail = (client->head - 2) & (client->bufsize - 1);

		client->buffer[client->tail].time = event->time;
		client->buffer[client->tail].type = EV_SYN;
		client->buffer[client->tail].code = SYN_DROPPED;
		client->buffer[client->tail].value = 0;

		client->packet_head = client->tail;
	}

	if (event->type == EV_SYN && event->code == SYN_REPORT) {
		client->packet_head = client->head;
		kill_fasync(&client->fasync, SIGIO, POLL_IN);
	}

	spin_unlock(&client->buffer_lock);
}
 
   
 
   
总结一下事件的传递过程：首先在驱动层中，调用inport_report_abs，然后他调用了input core层的input_event，input_event调用了input_handle_event对事件进行分派，调用input_pass_event，在这里他会把事件传递给具体的handler层，然后在相应handler的event处理函数中，封装一个event，然后把它投入evdev的那个client_list上的client的事件buffer中，等待用户空间来读取。
 
 
 
 
  
 
 
 


                            

                        

                    

                    
                    

                    
                    
                    

                

                

                    
                

            

        

    

    

        
你可能感兴趣的:(Linux设备驱动,input子系统框架)

        

            

                
    
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 利用LangChain的StackExchange组件实现智能问答系统
                        nseejrukjhad
langchainmicrosoft数据库python
                        
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • 自我意识
                        徐立华

                        
    ----读帕克.帕尔默《教学勇气》（P18----19）5.铸造我们的学科帕克.帕尔默说学科知识对我们的自身认同和外部世界有启发意义。学科会铸造我们。“在我们与学科的命题概念和学科的生活框架相遇之前，自我意识知识处于潜伏状态，通过回想学科是怎样唤醒自我意识，我们就可以找回教学心灵。”《教学勇气》（P18）我们的自我意识像冰山表面下无限延伸的冰层，常常处于潜伏状态。但是在我们对所教授的学科进行深入思
    
                    
    • 
                    
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作
                        GPJnCrbBdl
python开发语言
                        
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • insert into select 主键自增_mybatis拦截器实现主键自动生成
                        weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
                        
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • 今天是总结
                        薛帅

                        
    今天来个最后一天的总结。为什么要学习写作技巧呢？就如同建房子，如果想要住的安全、舒服，我们要先打地基，建房子的框架，这样才能随意的装修。那么我们要怎么建好才能建好写作的地基呢？1走直路，少弯路01利他：能够给别人带来价值。02吸引：吸住读者的眼球。03打动：打动人心，引起共鸣。04说服：用数据说话。05刻意：通过有意识的训练。06修改：好的文章至上修改10遍。07模仿：10万+的文章必有成功的道理
    
                    
    • 
                    
  • Python 课程10-单元测试
                        可愛小吉
Python教學python单元测试开发语言TDDunittest
                        
    前言在现代软件开发中，单元测试已成为一种必不可少的实践。通过测试，我们可以确保每个功能模块在开发和修改过程中按预期工作，从而减少软件缺陷，提高代码质量。而测试驱动开发（TDD）则进一步将测试作为开发的核心部分，先编写测试，再编写代码，以测试为指导开发出更稳定、更可靠的代码。Python提供了强大的unittest模块，它是Python标准库的一部分，专门用于编写和执行单元测试。与其他测试框架相比，
    
                    
    • 
                    
  • MyBatis 详解
                        阿贾克斯的黎明
javamybatis
                        
    目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
    
                    
    • 
                    
  • 【自动化测试】UI自动化的分类、如何选择合适的自动化测试工具以及其中appium的设计理念、引擎和引擎如何工作
                        Lossya
ui自动化测试工具自动化测试appium
                        
    引言UI自动化测试主要针对软件的用户界面进行测试，以确保用户界面元素的交互和功能符合预期文章目录引言一、UI自动化的分类1.1基于代码的自动化测试1.2基于录制/回放的自动化测试1.3基于框架的自动化测试1.4按测试对象分类1.5按测试层次分类1.6按测试执行方式分类1.7按测试目的分类二、如何选择合适的自动化测试工具2.1项目需求分析2.2工具特性评估2.3成本考虑2.4团队技能2.5试用和评估
    
                    
    • 
                    
  • python爬取微信小程序数据,python爬取小程序数据
                        2301_81900439
前端
                        
    大家好，小编来为大家解答以下问题，python爬取微信小程序数据，python爬取小程序数据，现在让我们一起来看看吧！Python爬虫系列之微信小程序实战基于Scrapy爬虫框架实现对微信小程序数据的爬取首先，你得需要安装抓包工具，这里推荐使用Charles，至于怎么使用后期有时间我会出一个事例最重要的步骤之一就是分析接口，理清楚每一个接口功能，然后连接起来形成接口串思路,再通过Spider的回调
    
                    
    • 
                    
  • 字节二面
                        Redstone Monstrosity
前端面试
                        
    1.假设你是正在面试前端开发工程师的候选人，面试官让你详细说出你上一段实习过程的收获和感悟。在上一段实习过程中，我获得了宝贵的实践经验和深刻的行业洞察，以下是我的主要收获和感悟：一、专业技能提升框架应用熟练度：通过实际项目，我深入掌握了React、Vue等前端框架的使用，不仅提升了编码效率，还学会了如何根据项目需求选择合适的框架。问题解决能力：在实习期间，我遇到了许多预料之外的技术难题。通过查阅文
    
                    
    • 
                    
  • 【Golang】实现 Excel 文件下载功能
                        RumIV
Golanggolangexcel开发语言
                        
    在当今的网络应用开发中，提供数据导出功能是一项常见的需求。Excel作为一种广泛使用的电子表格格式，通常是数据导出的首选格式之一。在本教程中，我们将学习如何使用Go语言和GinWeb框架来创建一个Excel文件，并允许用户通过HTTP请求下载该文件。准备工作在开始之前，请确保您的开发环境中已经安装了Go语言和相关的开发工具。此外，您还需要安装GinWeb框架和excelize包，这两个包都将用于我
    
                    
    • 
                    
  • golang 实现文件上传下载
                        wangwei830
go
                        
    Gin框架上传下载上传（支持批量上传）httpRouter.POST("/upload",func(ctx*gin.Context){forms,err:=ctx.MultipartForm()iferr!=nil{fmt.Println("error",err)}files:=forms.File["fileName"]for_,v:=rangefiles{iferr:=ctx.SaveUplo
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • Hadoop
                        傲雪凌霜，松柏长青
后端大数据hadoop大数据分布式
                        
    ApacheHadoop是一个开源的分布式计算框架，主要用于处理海量数据集。它具有高度的可扩展性、容错性和高效的分布式存储与计算能力。Hadoop核心由四个主要模块组成，分别是HDFS（分布式文件系统）、MapReduce（分布式计算框架）、YARN（资源管理）和HadoopCommon（公共工具和库）。1.HDFS（HadoopDistributedFileSystem）HDFS是Hadoop生
    
                    
    • 
                    
  • Python精选200Tips：121-125
                        AnFany
Python200+Tipspython开发语言
                        
    Spendyourtimeonself-improvement121Requests-简化的HTTP请求处理发送GET请求发送POST请求发送PUT请求发送DELETE请求会话管理处理超时文件上传122BeautifulSoup-网页解析和抓取解析HTML和XML文档查找单个标签查找多个标签使用CSS选择器查找标签提取文本修改文档内容删除标签处理XML文档123Scrapy-强大的网络爬虫框架示例
    
                    
    • 
                    
  • 【鸿蒙应用】总结一下ArkUI
                        读心悦
鸿蒙基础鸿蒙应用
                        
    ArkUI是HarmonyOS应用界面的UI开发框架，提供了简洁的UI语法、UI组件、动画机制和事件交互等等UI开发基础，以此满足应用开发者对UI界面开发的需求。组件是界面搭建的最小单位，开发者通过多种组件的组合构成完整的界面。页面是ArkUI最小的调度分隔单位，开发者可以将应用设计为多个功能页面，每一个页面进行单独的文件管理，并且通过页面路由API完成页面之间的调度管理，以此来实现应用内功能的解
    
                    
    • 
                    
  • 跟剽悍一只猫学习收获之成为领域专家
                        财务自由的社群运营人苏宝

                        
    001找到这个领域内权威的书籍。002按照书的脉络（章节目录）记录书中的重要内容（对自己认知系统造成冲击的，以前没有学过的，觉得有用的，暂时还不太理解的）记录下来。003读完第一遍以后，接着读第二遍。这一遍记录书里对你有用的方法论，并尝试依据这些方法论实战。004再读一遍，这一遍记录尝试梳理整个书的认知框架和内在逻辑。005之后，可以多朗读几遍全书。你会发现，你对这些知识的理解会越来越全面，越有深
    
                    
    • 
                    
  • 第二阶段学习的第二次复盘
                        蓝色沫

                        
    【昵称】蓝色，沫【我的技能】第二阶段所学内容中，我学习了如何学好爆款标题，如何写好开头和结尾，如何写好媒体文等等。【我要发问】第二阶段学习的内容中，没能掌握好写媒体文。【我的闪光点】第二阶段做的好的地方，有按时完成作业，以及认真听视频课，在课程中，明白了怎样去写好开头和结尾，怎样写出爆款标题等。【不足之处】没能掌握好写媒体文。关于写好媒体文，有些吃力，针对写三至五个小标题，以及写好媒体文框架还存在
    
                    
    • 
                                
  • Enum 枚举
                                    120153216
enum枚举
                                    
    原文地址：http://www.cnblogs.com/Kavlez/p/4268601.html Enumeration 
于Java 1.5增加的enum type...enum type是由一组固定的常量组成的类型，比如四个季节、扑克花色。在出现enum type之前，通常用一组int常量表示枚举类型。比如这样： 
public static final int APPLE_FUJI = 0
    
                                
    • 
                                
  • Java8简明教程
                                    bijian1013
javajdk1.8
                                    
            Java 8已于2014年3月18日正式发布了，新版本带来了诸多改进，包括Lambda表达式、Streams、日期时间API等等。本文就带你领略Java 8的全新特性。  
一.允许在接口中有默认方法实现 
        Java 8 允许我们使用default关键字，为接口声明添
    
                                
    • 
                                
  • Oracle表维护 快速备份删除数据
                                    cuisuqiang
oracle索引快速备份删除
                                    
    我知道oracle表分区，不过那是数据库设计阶段的事情，目前是远水解不了近渴。 
当前的数据库表，要求保留一个月数据，且表存在大量录入更新，不存在程序删除。 
为了解决频繁查询和更新的瓶颈，我在oracle内根据需要创建了索引。但是随着数据量的增加，一个半月数据就要超千万，此时就算有索引，对高并发的查询和更新来说，让然有所拖累。 
为了解决这个问题，我一般一个月会进行一次数据库维护，主要工作就是备
    
                                
    • 
                                
  • java多态内存分析
                                    麦田的设计者
java内存分析多态原理接口和抽象类
                                    
          “  时针如果可以回头，熟悉那张脸，重温嬉戏这乐园，墙壁的松脱涂鸦已经褪色才明白存在的价值归于记忆。街角小店尚存在吗？这大时代会不会牵挂，过去现在花开怎么会等待。 
      但有种意外不管痛不痛都有伤害，光阴远远离开，那笑声徘徊与脑海。但这一秒可笑不再可爱，当天心
    
                                
    • 
                                
  • Xshell实现Windows上传文件到Linux主机
                                    被触发
windows
                                    
    经常有这样的需求，我们在Windows下载的软件包，如何上传到远程Linux主机上？还有如何从Linux主机下载软件包到Windows下；之前我的做法现在看来好笨好繁琐，不过也达到了目的，笨人有本方法嘛； 
我是怎么操作的： 
1、打开一台本地Linux虚拟机，使用mount 挂载Windows的共享文件夹到Linux上，然后拷贝数据到Linux虚拟机里面；（经常第一步都不顺利，无法挂载Windo
    
                                
    • 
                                
  • 类的加载ClassLoader
                                    肆无忌惮_
ClassLoader
                                    
    类加载器ClassLoader是用来将java的类加载到虚拟机中，类加载器负责读取class字节文件到内存中，并将它转为Class的对象（类对象），通过此实例的 newInstance()方法就可以创建出该类的一个对象。 
  
其中重要的方法为findClass(String name)。 
  
如何写一个自己的类加载器呢？ 
首先写一个便于测试的类Student
    
                                
    • 
                                
  • html5写的玫瑰花
                                    知了ing
html5
                                    
    <html>  
<head>  
<title>I Love You!</title>  
<meta charset="utf-8" />  
</head>  
<body>  
<canvas id="c"></canvas>  

    
                                
    • 
                                
  • google的ConcurrentLinkedHashmap源代码解析
                                    矮蛋蛋
LRU
                                    
    原文地址： 
http://janeky.iteye.com/blog/1534352 
简述 
ConcurrentLinkedHashMap 是google团队提供的一个容器。它有什么用呢？其实它本身是对 
 
ConcurrentHashMap的封装，可以用来实现一个基于LRU策略的缓存。详细介绍可以参见 
 
http://code.google.com/p/concurrentlinke
    
                                
    • 
                                
  • webservice获取访问服务的ip地址
                                    alleni123
webservice
                                    
    1. 首先注入javax.xml.ws.WebServiceContext, 
@Resource 
 private WebServiceContext context; 
 
 
2. 在方法中获取交换请求的对象。 
 
 
javax.xml.ws.handler.MessageContext mc=context.getMessageContext();
com.sun.net.http
    
                                
    • 
                                
  • 菜鸟的java基础提升之道——————>是否值得拥有
                                    百合不是茶

                                    
    1，c++，java是面向对象编程的语言，将万事万物都看成是对象；java做一件事情关注的是人物，java是c++继承过来的，java没有直接更改地址的权限但是可以通过引用来传值操作地址，java也没有c++中繁琐的操作，java以其优越的可移植型，平台的安全型，高效性赢得了广泛的认同，全世界越来越多的人去学习java，我也是其中的一员 
  
  
 java组成：
    
                                
    • 
                                
  • 通过修改Linux服务自动启动指定应用程序
                                    bijian1013
linux
                                    
    Linux中修改系统服务的命令是chkconfig (check config)，命令的详细解释如下:  chkconfig

功能说明：检查，设置系统的各种服务。

语　　法：chkconfig [ -- add][ -- del][ -- list][系统服务] 或 chkconfig [ -- level  <</SPAN>
    
                                
    • 
                                
  • spring拦截器的一个简单实例
                                    bijian1013
javaspring拦截器Interceptor
                                    
    Purview接口 
package aop;

public interface Purview {
    void checkLogin();
} 
Purview接口的实现类PurviesImpl.java 
package aop;

public class PurviewImpl implements Purview {
	
    public void check
    
                                
    • 
                                
  • [Velocity二]自定义Velocity指令
                                    bit1129
velocity
                                    
    什么是Velocity指令 
在Velocity中，#set,#if, #foreach, #elseif, #parse等，以#开头的称之为指令，Velocity内置的这些指令可以用来做赋值，条件判断，循环控制等脚本语言必备的逻辑控制等语句，Velocity的指令是可扩展的，即用户可以根据实际的需要自定义Velocity指令 
  自定义指令(Directive)的一般步骤 
&nbs
    
                                
    • 
                                
  • 【Hive十】Programming Hive学习笔记
                                    bit1129
programming
                                    
     第二章 Getting Started 
1.Hive最大的局限性是什么？一是不支持行级别的增删改(insert, delete, update)二是查询性能非常差(基于Hadoop MapReduce）,不适合延迟小的交互式任务三是不支持事务2. Hive MetaStore是干什么的？Hive persists table schemas and other system metadata.
    
                                
    • 
                                
  • nginx有选择性进行限制
                                    ronin47
nginx 动静　限制
                                    
    http {
    limit_conn_zone $binary_remote_addr zone=addr:10m;
    limit_req_zone $binary_remote_addr zone=one:10m rate=5r/s;...

    server {...
       location ~.*\.(gif|png|css|js|icon)$ {
   
    
                                
    • 
                                
  • java-4.-在二元树中找出和为某一值的所有路径 .
                                    bylijinnan
java
                                    
    
/*
	 * 0.use a TwoWayLinkedList to store the path.when the node can't be path,you should/can delete it.
	 * 1.curSum==exceptedSum:if the lastNode is TreeNode,printPath();delete the node otherwise

    
                                
    • 
                                
  • Netty学习笔记
                                    bylijinnan
javanetty
                                    
    本文是阅读以下两篇文章时： 
 
http://seeallhearall.blogspot.com/2012/05/netty-tutorial-part-1-introduction-to.html 
 
http://seeallhearall.blogspot.com/2012/06/netty-tutorial-part-15-on-channel.html 
我的一些笔记 
 
===
    
                                
    • 
                                
  • js获取项目路径
                                    cngolon
js
                                    
    //js获取项目根路径，如： http://localhost:8083/uimcardprj 
function getRootPath(){ 
    //获取当前网址，如： http://localhost:8083/uimcardprj/share/meun.jsp 
    var curWwwPath=window.document.locati
    
                                
    • 
                                
  • oracle 的性能优化
                                    cuishikuan
oracleSQL Server
                                    
       在网上搜索了一些Oracle性能优化的文章，为了更加深层次的巩固[边写边记]，也为了可以随时查看，所以发表这篇文章。 
    1.ORACLE采用自下而上的顺序解析WHERE子句，根据这个原理，表之间的连接必须写在其他WHERE条件之前，那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾。（这点本人曾经做过实例验证过，的确如此哦！
    
                                
    • 
                                
  • Shell变量和数组使用详解
                                    daizj
linuxshell变量数组
                                    
    Shell 变量 
定义变量时，变量名不加美元符号（$，PHP语言中变量需要），如： 
your_name="w3cschool.cc" 
注意，变量名和等号之间不能有空格，这可能和你熟悉的所有编程语言都不一样。同时，变量名的命名须遵循如下规则： 
 
 首个字符必须为字母（a-z，A-Z）。 
 中间不能有空格，可以使用下划线（_）。 
 不能使用标点符号。 
 不能使用ba
    
                                
    • 
                                
  • 编程中的一些概念，KISS、DRY、MVC、OOP、REST
                                    dcj3sjt126com
REST
                                    
    KISS、DRY、MVC、OOP、REST （1）KISS是指Keep It Simple,Stupid（摘自wikipedia），指设计时要坚持简约原则，避免不必要的复杂化。 （2）DRY是指Don't Repeat Yourself（摘自wikipedia），特指在程序设计以及计算中避免重复代码，因为这样会降低灵活性、简洁性，并且可能导致代码之间的矛盾。 （3）OOP 即Object-Orie
    
                                
    • 
                                
  • [Android]设置Activity为全屏显示的两种方法
                                    dcj3sjt126com
Activity
                                    
    1. 方法1：AndroidManifest.xml 里，Activity的 android:theme  指定为" @android:style/Theme.NoTitleBar.Fullscreen" 示例:   <application      
    
                                
    • 
                                
  • solrcloud 部署方式比较
                                    eksliang
solrCloud
                                    
    solrcloud 的部署其实有两种方式可选，那么我们在实践开发中应该怎样选择呢？ 第一种：当启动solr服务器时，内嵌的启动一个Zookeeper服务器，然后将这些内嵌的Zookeeper服务器组成一个集群。  第二种：将Zookeeper服务器独立的配置一个集群，然后将solr交给Zookeeper进行管理 
  
谈谈第一种：每启动一个solr服务器就内嵌的启动一个Zoo
    
                                
    • 
                                
  • Java synchronized关键字详解
                                    gqdy365
synchronized
                                    
    转载自：http://www.cnblogs.com/mengdd/archive/2013/02/16/2913806.html 
 
多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作，同步用以解决多个线程同时访问时可能出现的问题。 
同步机制可以使用synchronized关键字实现。 
当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。 
当s
    
                                
    • 
                                
  • js实现登录时记住用户名
                                    hw1287789687
记住我记住密码cookie记住用户名记住账号
                                    
    在页面中如何获取cookie值呢? 
如果是JSP的话,可以通过servlet的对象request 获取cookie,可以 
参考:http://hw1287789687.iteye.com/blog/2050040 
如果要求登录页面是html呢?html页面中如何获取cookie呢? 
直接上代码了 
页面:loginInput.html 
代码: 
<!DOCTYPE html PUB
    
                                
    • 
                                
  • 开发者必备的 Chrome 扩展
                                    justjavac
chrome
                                    
    Firebug：不用多介绍了吧https://chrome.google.com/webstore/detail/bmagokdooijbeehmkpknfglimnifench 
ChromeSnifferPlus：Chrome 探测器，可以探测正在使用的开源软件或者 js 类库https://chrome.google.com/webstore/detail/chrome-sniffer-pl
    
                                
    • 
                                
  • 算法机试题
                                    李亚飞
java算法机试题
                                    
           在面试机试时，遇到一个算法题，当时没能写出来，最后是同学帮忙解决的。 
       这道题大致意思是：输入一个数，比如4,。这时会输出： 
          &n
    
                                
    • 
                                
  • 正确配置Linux系统ulimit值
                                    字符串
ulimit
                                    
    在Linux下面部 署应用的时候，有时候会遇上Socket/File: Can’t open so many files的问题；这个值也会影响服务器的最大并发数，其实Linux是有文件句柄限制的，而且Linux默认不是很高，一般都是1024，生产服务器用 其实很容易就达到这个数量。下面说的是，如何通过正解配置来改正这个系统默认值。因为这个问题是我配置Nginx+php5时遇到了，所以我将这篇归纳进
    
                                
    • 
                                
  • hibernate调用返回游标的存储过程
                                    Supanccy2013
javaDAOoracleHibernatejdbc
                                    
    注：原创作品，转载请注明出处。 
 
 
    上篇博文介绍的是hibernate调用返回单值的存储过程，本片博文说的是hibernate调用返回游标的存储过程。 
    此此扁博文的存储过程的功能相当于是jdbc调用select 的作用。 
 
1，创建oracle中的包，并在该包中创建的游标类型。 
 
---创建oracle的程
    
                                
    • 
                                
  • Spring 4.2新特性-更简单的Application Event
                                    wiselyman
application
                                    
    1.1 Application Event 
 
  Spring 4.1的写法请参考10点睛Spring4.1-Application Event  
  请对比10点睛Spring4.1-Application Event  
  使用一个@EventListener取代了实现ApplicationListener接口,使耦合度降低;  
  
1.2 示例 
 
 包依赖 
  
<p
    
                                
    • 
                

            

        

    




    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他