sir_zeng
sir_zeng

linux input输入子系统分析《四》：input子系统整体流程全面分析

1      input输入子系统整体流程

本节分析input子系统在内核中的实现，包括输入子系统（Input Core），事件处理层（Event Handler）和设备驱动层。由于上节代码讲解了设备驱动层的写法，因此在开头部分会从设备驱动层做为线索，分析输入子系统和事件处理层是如何配合的，最后从用户角度出发，从“/dev/input/*”接口如何使用输入子系统提供的服务。

既然需要详细分析，有一个这样的流程图能够帮助我们在被绕进代码的过程中，找到出口，你能够知道你现在位于代码框架的什么位置，不会忘记正在分析的代码的“身份”。其实在初识输入子系统中已经贴出了这张图，我们再把它拿出来参考一下吧，见下图6。

linux input输入子系统分析《四》：input子系统整体流程全面分析_第1张图片

图6  linux输入子系统事件处理机制

1.1    设备驱动层注册到input子系统

在上一节分析了S3C2440触摸屏驱动的代码，初始化函数定义了struct input_devinput结构体，它用于描述一个输入子系统设备，任何驱动设备如果想标明自己是输入设备，都应该通过初始化这样的结构体，并且调用input_allocate_device（）函数进行注册。

了解这一过程，需要先看一下structinput_dev结构体的内容：

[cpp] view plain copy
  1. struct input_dev { 
  2.  
  3.     void *private;              //输入设备私有指针，一般指向用于描述设备驱动层的设备结构 
  4.  
  5.     const char *name;           //提供给用户的输入设备的名称 
  6.     const char *phys;           //提供给编程者的设备节点的名称 
  7.     const char *uniq;           //指定唯一的ID号，就像MAC地址一样 
  8.     struct input_id id;         //输入设备标识ID，用于和事件处理层进行匹配 
  9.  
  10.     unsigned long evbit[NBITS(EV_MAX)];     //位图，记录设备支持的事件类型 
  11.     unsigned long keybit[NBITS(KEY_MAX)];       //位图，记录设备支持的按键类型 
  12.     unsigned long relbit[NBITS(REL_MAX)];       //位图，记录设备支持的相对坐标 
  13.     unsigned long absbit[NBITS(ABS_MAX)];       //位图，记录设备支持的绝对坐标 
  14.     unsigned long mscbit[NBITS(MSC_MAX)];   //位图，记录设备支持的其他功能 
  15.     unsigned long ledbit[NBITS(LED_MAX)];       //位图，记录设备支持的指示灯 
  16.     unsigned long sndbit[NBITS(SND_MAX)];       //位图，记录设备支持的声音或警报 
  17.     unsigned long ffbit[NBITS(FF_MAX)];     //位图，记录设备支持的作用力功能 
  18.     unsigned long swbit[NBITS(SW_MAX)];     //位图，记录设备支持的开关功能 
  19.  
  20.     unsigned int keycodemax;        //设备支持的最大按键值个数 
  21.     unsigned int keycodesize;       //每个按键的字节大小 
  22.     void *keycode;              //指向按键池，即指向按键值数组首地址 
  23.     int (*setkeycode)(struct input_dev *dev, int scancode, int keycode);    //修改按键值 
  24.     int (*getkeycode)(struct input_dev *dev, int scancode, int *keycode);   //获取按键值 
  25.  
  26.     struct ff_device *ff;           //用于强制更新输入设备的部分内容 
  27.  
  28.     unsigned int repeat_key;        //重复按键的键值 
  29.     struct timer_list timer;        //设置当有连击时的延时定时器 
  30.  
  31.     int state;      //设备状态 
  32.  
  33.     int sync;       //同步事件完成标识，为1说明事件同步完成 
  34.  
  35.     int abs[ABS_MAX + 1];       //记录坐标的值 
  36.     int rep[REP_MAX + 1];       //记录重复按键的参数值 
  37.  
  38.     unsigned long key[NBITS(KEY_MAX)];      //位图，按键的状态 
  39.     unsigned long led[NBITS(LED_MAX)];      //位图，led的状态 
  40.     unsigned long snd[NBITS(SND_MAX)];      //位图，声音的状态 
  41.     unsigned long sw[NBITS(SW_MAX)];            //位图，开关的状态 
  42.  
  43.     int absmax[ABS_MAX + 1];                    //位图，记录坐标的最大值 
  44.     int absmin[ABS_MAX + 1];                    //位图，记录坐标的最小值 
  45.     int absfuzz[ABS_MAX + 1];                   //位图，记录坐标的分辨率 
  46.     int absflat[ABS_MAX + 1];                   //位图，记录坐标的基准值 
  47.  
  48.     int (*open)(struct input_dev *dev);         //输入设备打开函数 
  49.     void (*close)(struct input_dev *dev);           //输入设备关闭函数 
  50.     int (*flush)(struct input_dev *dev, struct file *file); //输入设备断开后刷新函数 
  51.     int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);   //事件处理 
  52.  
  53.     struct input_handle *grab;      //类似私有指针，可以直接访问到事件处理接口event 
  54.  
  55.     struct mutex mutex;     //用于open、close函数的连续访问互斥 
  56.     unsigned int users;     //设备使用计数 
  57.  
  58.     struct class_device cdev;   //输入设备的类信息 
  59.     union {             //设备结构体 
  60.         struct device *parent; 
  61.     } dev; 
  62.  
  63.     struct list_head    h_list; //handle链表 
  64.     struct list_head    node;   //input_dev链表 
  65. }; 

也许就这样赤裸裸的看上面的结构体，会觉得摸不着头脑，但是有一点是确定的，我们在写输入设备驱动时会定义这样一个输入设备结构体，并调用input_allocate_device()函数，这个函数的功能是为新添加的输入设备分配内存，如果成功，将返回input_dev *的指针结构，因此在写驱动的时候应该接受返回值，作为驱动层获得了一个新的输入设备操作的接口。

那么input_allocate_device()函数做了什么呢？打开函数看一下（input.c中实现）：

[cpp] view plain copy
  1. struct input_dev *input_allocate_device(void) 
  2. { 
  3.     struct input_dev *dev; 
  4.  
  5. //动态申请内存，使用GFP_KERNEL方式，注意GFP_KERNEL可能导致睡眠，不能在中断中调用这个函数 
  6.     dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL); 
  7. //分配成功执行的代码，进行成员的默认填充 
  8.     if (dev) { 
  9.         dev->cdev.class = &input_class;          //支持热插拔的结构体 
  10.         dev->cdev.groups = input_dev_attr_groups; //描述设备的硬件信息和支持的事件类型 
  11.         class_device_initialize(&dev->cdev);     //类设备初始化，添加进input类设备模型中 
  12.         mutex_init(&dev->mutex);             //初始化互斥锁 
  13.         INIT_LIST_HEAD(&dev->h_list);        //初始化handle链表 
  14.         INIT_LIST_HEAD(&dev->node);          //初始化输入设备链表 
  15.  
  16.     } 
  17. } 

通过input_allocate_device()函数，我们设备驱动现在持有的input_dev里面就被赋予了input的“形象”，但是还需要我们去充实一下“内在”，因此，设备驱动程序，还需要为自己的设备增加自己的特性，才能创造独有的设备“形象”。拿上一节的代码举例如下：

[cpp] view plain copy
  1. struct input_dev *input_dev = input_allocate_device(); 
  2. input_dev->name = "s3c2410 Touchscreen"; 
  3. input_dev->phys = "s3c2410ts/input0"; 
  4. input_dev->id.bustype = BUS_HOST; 
  5. input_dev->id.vendor = 0x0001; 
  6. input_dev->id.product = 0x0002; 
  7. input_dev->id.version = 0x0100; 
  8. input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 
  9. input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);  
  10. input_set_abs_params(input_dev, ABS_X, X_AXIS_MIN, X_AXIS_MAX, 0, 0); 
  11. input_set_abs_params(input_dev, ABS_Y, Y_AXIS_MIN, Y_AXIS_MAX, 0, 0); 
  12. input_set_abs_params(input_dev, ABS_PRESSURE, PRESSURE_MIN, PRESSURE_MAX, 0, 0); 

以上的内容在前一节触摸屏驱动的初始化代码中也有分析，完成了输入设备的初始化工作。但是这仅是初始化自己的“特点”，还需要通知输入子系统有这样一个新设备诞生了，这就需要调用输入子系统的注册函数input_register_device（input_dev）来完成。

input_register_device（）用于注册一个输入设备。那么注册过程是怎样的呢？这是一个重点，我们在下面的代码中进行注释分析：

[cpp] view plain copy
  1. int input_register_device(struct input_dev *dev) 
  2. { 
  3.     /* 用于记录输入设备名称的索引值 */ 
  4.     static atomic_t input_no = ATOMIC_INIT(0); 
  5.     /* 输入事件的处理接口指针，用于和设备的事件类型进行匹配 */ 
  6.     struct input_handler *handler; 
  7.     const char *path; 
  8.     int error; 
  9.  
  10.     /* 默认所有的输入设备都支持EV_SYN同步事件 */ 
  11.     set_bit(EV_SYN, dev->evbit); 
  12.  
  13.     /*
  14.      * 如果设备驱动没有指定重复按键（连击），系统默认提供以下的支持
  15.      * 其中init_timer为连击产生的定时器，时间到调用input_repeat_key函数
  16.      * 上报，REP_DELAY用于设置重复按键的键值，REP_PERIOD设置延时时间
  17.      */ 
  18.     init_timer(&dev->timer); 
  19.     if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) { 
  20.         dev->timer.data = (long) dev; 
  21.         dev->timer.function = input_repeat_key; 
  22.         dev->rep[REP_DELAY] = 250; 
  23.         dev->rep[REP_PERIOD] = 33; 
  24.     } 
  25.  
  26.     /* 如果设备驱动没有设置自己的获取键值的函数，系统默认 */ 
  27.     if (!dev->getkeycode) 
  28.         dev->getkeycode = input_default_getkeycode; 
  29.  
  30.     /* 如果设备驱动没有指定按键重置函数，系统默认 */ 
  31.     if (!dev->setkeycode) 
  32.         dev->setkeycode = input_default_setkeycode; 
  33.  
  34.     /* 重要，把设备挂到全局的input子系统设备链表input_dev_list上 */ 
  35.     list_add_tail(&dev->node, &input_dev_list); 
  36.  
  37.     /* 动态获取input设备的ID号，名称为input*，其中后面的“*”动态获得，唯一的 */ 
  38.     snprintf(dev->cdev.class_id, sizeof(dev->cdev.class_id), 
  39.          "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1); 
  40.  
  41.     /* 如果这个值没有设置，系统把输入设备挂入设备链表 */ 
  42.     if (!dev->cdev.dev) 
  43.         dev->cdev.dev = dev->dev.parent; 
  44.  
  45.     /* 在/sys目录下创建设备目录和文件 */ 
  46.     error = class_device_add(&dev->cdev); 
  47.     if (error) 
  48.         return error; 
  49.  
  50.     /* 获取并打印设备的绝对路径名称 */ 
  51.     path = kobject_get_path(&dev->cdev.kobj, GFP_KERNEL); 
  52.     printk(KERN_INFO "input: %s as %s\n", 
  53.         dev->name ? dev->name : "Unspecified device", path ? path : "N/A"); 
  54.     kfree(path); 
  55.  
  56.     /* 核心重点，input设备在增加到input_dev_list链表上之后，会查找
  57.      * input_handler_list事件处理链表上的handler进行匹配，这里的匹配
  58.      * 方式与设备模型的device和driver匹配过程很相似，所有的input
  59.      * 都挂在input_dev_list上，所有类型的事件都挂在input_handler_list
  60.      * 上，进行“匹配相亲”*/ 
  61.     list_for_each_entry(handler, &input_handler_list, node) 
  62.         input_attach_handler(dev, handler); 
  63.  
  64.     input_wakeup_procfs_readers(); 
  65.  
  66.     return 0; 
  67. } 

上面的代码主要的功能有以下几个功能，也是设备驱动注册为输入设备委托内核做的事情：

  • 进一步初始化输入设备，例如连击事件；
  • 注册输入设备到input类中；
  • 把输入设备挂到输入设备链表input_dev_list中；
  • 查找并匹配输入设备对应的事件处理层，通过input_handler_list链表

我们需要再分析下这个匹配的过程，“相亲”这种事情还是很有意思的，但是需要注意的是下面分析的代码是我们暂时无法分析的，因为那样会使得情况变得更加复杂，当我们从应用层往下分析的时候一切都会明白。input_attach_handler匹配过程如下：

[cpp] view plain copy
  1. const struct input_device_id *id; 
  2.     int error; 
  3.  
  4. /* 如果handler的blacklist被赋值了并且则优先匹配 */ 
  5.     if (handler->blacklist && input_match_device(handler->blacklist, dev)) 
  6.         return -ENODEV; 
  7.  
  8.     /* 否则利用handler->id_table和dev进行匹配，后面讲述匹配什么和过程 */ 
  9.     id = input_match_device(handler->id_table, dev); 
  10.     if (!id) 
  11.         return -ENODEV; 
  12.  
  13.     /* 这是一根“红线”，虽然你可能觉的是黑色的，但不可否认，他们真的匹配上了
  14.          * 调用handler->connnect函数进行匹配，匹配详细过程后面讲述
  15.         */ 
  16.     error = handler->connect(handler, dev, id); 
  17.     if (error && error != -ENODEV) 
  18.         printk(KERN_ERR 
  19.             "input: failed to attach handler %s to device %s, " 
  20.             "error: %d\n", 
  21.             handler->name, kobject_name(&dev->cdev.kobj), error); 
  22.  
  23.     return error; 

我们先来看下input_match_device（）函数，看一下这个匹配的条件是什么，如何匹配的过程是怎样的，匹配的结果会是什么？

[cpp] view plain copy
  1. /* 事件处理层中的对应flags如果设置或者driver_info被设置则进行匹配 */ 
  2.     for (; id->flags || id->driver_info; id++) { 
  3.         /* 以下通过flags中设置的位来匹配设备的总线类型、经销商、生产ID和版本ID
  4.           如果没有匹配上将进行MATCH_BIT匹配 */ 
  5.         if (id->flags & INPUT_DEVICE_ID_MATCH_BUS) 
  6.             if (id->bustype != dev->id.bustype) 
  7.                 continue; 
  8.  
  9.         if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR) 
  10.             if (id->vendor != dev->id.vendor) 
  11.                 continue; 
  12.  
  13.         if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT) 
  14.             if (id->product != dev->id.product) 
  15.                 continue; 
  16.  
  17.         if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION) 
  18.             if (id->version != dev->id.version) 
  19.                 continue; 
  20.          
  21.         /* MATCH_BIT用于匹配设备驱动中是否设置了这些为，MATCH_BIT的宏
  22.         * 被定义在input.c中，我们在设备驱动中设置的事件类型会与事件链表中的
  23.         * 所有事件类型进行比较，匹配成功了将返回id，证明真的很合适，否则NULL
  24.         */ 
  25.         MATCH_BIT(evbit,  EV_MAX); 
  26.         MATCH_BIT(keybit, KEY_MAX); 
  27.         MATCH_BIT(relbit, REL_MAX); 
  28.         MATCH_BIT(absbit, ABS_MAX); 
  29.         MATCH_BIT(mscbit, MSC_MAX); 
  30.         MATCH_BIT(ledbit, LED_MAX); 
  31.         MATCH_BIT(sndbit, SND_MAX); 
  32.         MATCH_BIT(ffbit,  FF_MAX); 
  33.         MATCH_BIT(swbit,  SW_MAX); 
  34.  
  35.         return id; 
  36.     } 
  37.  
  38.     return NULL; 

既然证明是合适的，接下来就应该登记注册，并公证了。还记得handler->connect(handler, dev, id)函数吧，当input_match_device（）找到最合适的事件处理层驱动时，便执行handler->connect函数进行公证了，看下面这部分代码（假如说找到了evdev类型的驱动，在input/evdev.c中）：

[cpp] view plain copy
  1. struct evdev *evdev; 
  2.     struct class_device *cdev; 
  3.     dev_t devt; 
  4.     int minor; 
  5.     int error; 
  6.  
  7.     /* EVDEV_MINORS为32，代表共能容纳32个evdev事件层设备，下面代码在找到空的地方，用于保存evdev事件层的数据，即上面定义的evdev */ 
  8.     for (minor = 0; minor < EVDEV_MINORS && evdev_table[minor]; minor++); 
  9.     /* 这说明内核已经没办法再分配这种类型的设备了 */ 
  10.     if (minor == EVDEV_MINORS) { 
  11.         printk(KERN_ERR "evdev: no more free evdev devices\n"); 
  12.         return -ENFILE; 
  13.     } 
  14.     /* 开始给evdev事件层驱动分配空间了 */ 
  15.     evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); 
  16.     if (!evdev) 
  17.         return -ENOMEM; 
  18.  
  19.     /* 初始化client_list列表和evdev_wait队列，后面介绍 */ 
  20.     INIT_LIST_HEAD(&evdev->client_list); 
  21.     init_waitqueue_head(&evdev->wait); 
  22.  
  23.     /* 初始化evdev结构体，其中handle为输入设备和事件处理的关联接口 */ 
  24.     evdev->exist = 1; 
  25.     evdev->minor = minor; 
  26.     evdev->handle.dev = dev; 
  27.     evdev->handle.name = evdev->name; 
  28.     evdev->handle.handler = handler; 
  29.     evdev->handle.private = evdev; 
  30.     sprintf(evdev->name, "event%d", minor); 
  31.  
  32.     /* 重要，上层访问时通过次设备号找到事件处理的接口 */ 
  33.     evdev_table[minor] = evdev; 
  34.  
  35.     /* evdev事件设备的此设备号的基准值INPUT_MAJOR, EVDEV_MINOR_BASE */ 
  36.     devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor), 
  37.  
  38.     /* 创建用户事件驱动层设备访问接口/dev/input/event* */ 
  39.     cdev = class_device_create(&input_class, &dev->cdev, devt, 
  40.                    dev->cdev.dev, evdev->name); 
  41.     if (IS_ERR(cdev)) { 
  42.         error = PTR_ERR(cdev); 
  43.         goto err_free_evdev; 
  44.     } 
  45.  
  46.     /* 提供/sys目录的用户空间接口 */ 
  47.     error = sysfs_create_link(&input_class.subsys.kobj, 
  48.                   &cdev->kobj, evdev->name); 
  49.     if (error) 
  50.         goto err_cdev_destroy; 
  51.  
  52.     /* input_dev设备驱动和handler事件处理层的关联，由handle完成 */ 
  53.     error = input_register_handle(&evdev->handle); 

通过上述代码的执行，最终，输入设备在input_register_handle（）的关联下与已经匹配上的handler结合，代码如下：

[cpp] view plain copy
  1. struct input_handler *handler = handle->handler; 
  2.     /* 将d_node链接到输入设备的h_list，h_node链接到事件层的h_list链表上
  3.     * 因此，在handle中是输入设备和事件层的关联结构体，通过输入设备可以
  4.     * 找到对应的事件处理层接口，通过事件处理层也可找到匹配的输入设备
  5.     */ 
  6.     list_add_tail(&handle->d_node, &handle->dev->h_list); 
  7.     list_add_tail(&handle->h_node, &handler->h_list); 
  8.  
  9.     /* 如果start函数有定义则调用，但是evdev结构体中并未初始化这个函数 */ 
  10.     if (handler->start) 
  11.         handler->start(handle); 

以上是输入设备驱动注册的全过程，牵涉的代码比较多，需要从宏观上理顺。纵观整个过程，输入设备驱动最终的目的就是能够与事件处理层的事件驱动相互匹配，但是在drivers/input目录下有evdev.c事件驱动、mousedev.c事件驱动、joydev.c事件驱动等等，我们的输入设备产生的事件应该最终上报给谁，然后让事件驱动再去处理呢？知道了这么个原因再看上面代码就会明白，其实evdev.c、mousedev.c等根据硬件输入设备的处理方式的不同抽象出了不同的事件处理接口帮助上层去调用，而我们写的设备驱动程序只不过是完成了硬件寄存器中数据的读写，但提交给用户的事件必须是经过事件处理层的封装和同步才能够完成的，事件处理层提供给用户一个统一的界面来操作。

由于以上的这些原因，才有了上述代码的关联过程，通过下图7，看一下整个关联注册的过程：


图7  input_dev与handler关联图

通过上图我们可以看到input输入设备匹配关联的关键过程以及涉及到的关键函数和数据。这一节主要是从input设备驱动程序的角度去看输入子系统的注册过程和三层之间的关联，下一节将从应用层的角度分析事件的接受过程和处理过程以及三层之间是如何配合处理输入事件的。

1.2    从应用层的角度出发看input子系统

以上部分已经借助input子系统把input设备驱动层与事件驱动层进行了关联，我们以前面几节所介绍的s3c2440_ts.c（输入设备层驱动）和evdev.c（事件处理层驱动）为例，来分析这一过程。

由于s3c2440_ts.c中上报的事件类型为按键、绝对值坐标，而evdev事件驱动程序是全匹配的，因此早在s3c2440_ts.c注册的过程中，就会创建设备节点/dev/input/event0（假设内核中没有其他的event类型的输入设备，这里就是event0），当然由于我的内核是2.6.22，这个节点的名字是/dev/event0。因此需要注意你的内核版本，以确定设备节点的位置，我们以“/dev/event0”为例来说明。

我们知道，应用层使用设备的第一步，是open(“/dev/event0”)，因此这里event0的主设备号成为关键，因为主设备号将表明你是什么设备，我们ls -l查看/dev/event0发现：

crw-r-----1 root root 13, 64 2012-07-26 14:32 /dev/input/event0

由此可见主设备是13，输入命令cat /proc/devices查看主设备为13的是input设备，因此可以确定当我们执行open函数打开event0设备的时候，会调用input设备的open驱动函数，这个函数在input.c中，为了说明这一问题，需要从input驱动注册过程开始，还是input.c文件：

[cpp] view plain copy
  1. /* 输入设备初始化函数 */ 
  2. static int __init input_init(void) 
  3. { 
  4.        class_register(&input_class); 
  5.        input_proc_init(); 
  6.        register_chrdev(INPUT_MAJOR,"input", &input_fops); 
  7. } 

可以看到，输入设备初始化的过程首先建立了input类，初始化input在proc下的节点，然后注册input设备，设备名称为input，操作接口是input_fops，主设备号是INPUT_MAJOR=13。

由以上可知，只要是主设备号为13的设备驱动程序，都是用input_fops接口，即当event0设备使用open函数打开时，会调用到input_fops接口中的open驱动函数，这个结构体的初始化为：

[cpp] view plain copy
  1. static const struct file_operations input_fops = { 
  2.        .owner = THIS_MODULE, 
  3.        .open = input_open_file, 
  4. }; 

可以看到，只实现了一个open功能字段，再看input_open_file的实现：

[cpp] view plain copy
  1. static int input_open_file(struct inode *inode, struct file *file) 
  2. { 
  3.        struct input_handler *handler =input_table[iminor(inode) >> 5]; 
  4.        const struct file_operations *old_fops,*new_fops = NULL; 
  5.        if (!handler || !(new_fops =fops_get(handler->fops))) 
  6.               return -ENODEV; 
  7.        old_fops = file->f_op; 
  8.        file->f_op = new_fops; 
  9.        new_fops->open(inode, file); 
  10. } 

以上代码的功能为找到对应事件驱动层的fops，即进行fops的接口转换，指向对应设备的事件处理接口。其中input_table[iminor(inode)]>>5的input_table是一个全局的input_handler类型的数组，iminor(inode)取得次设备号，并且右移5位索引input_table表中对应的位置，为什么这样做呢？这是因为这个表格中填写的就是事件处理的指针，我们待会分析，先继续查看下面的代码。if中将判断是否为空并且事件处理层中的fops有没有初始化，如果没有就不能进行接口转换，报出设备不存在的错误，如果设备存在则把input设备的f_op驱动接口指向input_table表中存在的接口，并调用其open函数。那么这个input_table里面到底存放了什么呢？我们还是拿触摸屏驱动来讲解。由于触摸屏驱动已经完成了和evdev.c事件处理层的匹配，且次设备号为64，设备名称为/dev/event0，这是我们通过分析驱动注册中获得的内容，既然input核心设备注册了，s3c2440触摸屏驱动也注册了，那会不会evdev设备也会注册了呢？答案是肯定的，要想知道input_table里面放了什么，必须要去查看evdev设备的注册过程，打开input/evdev.c查看它的注册过程：

[cpp] view plain copy
  1. static struct input_handler evdev_handler = { 
  2.        .event =   evdev_event,                               //事件处理 
  3.        .connect =      evdev_connect,                    //设备连接 
  4.        .disconnect =  evdev_disconnect,                //注销连接 
  5.        .fops =           &evdev_fops,                      //驱动功能接口 
  6.        .minor =  EVDEV_MINOR_BASE,              //evdev的值为64 
  7.        .name =          "evdev",                              //设备名称 
  8.        .id_table =      evdev_ids,                           //用于匹配设备驱动的数组 
  9. }; 
  10.   
  11. static int __init evdev_init(void) 
  12. { 
  13.        return input_register_handler(&evdev_handler);          //evdev设备驱动注册 
  14. } 

由以上的内容可以知道evdev_handler也被作为一个设备来操作，但是它属于input handler事件处理设备，然而我们在evdev_handler结构体的.fops字段又发现它的驱动接口为字符设备类型，在input中，如果input_table匹配到了evdev_handler，将会把file->f_op=&evdev_fops，那么如果使用read、write等函数操作，将会调用到evdev_fops中的read、write。

为了进一步查看input_table表中的内容是如何填充的，还需要查看这个注册的过程：

[cpp] view plain copy
  1. int input_register_handler(struct input_handler *handler) 
  2. { 
  3.     …… 
  4.            input_table[handler->minor>> 5] = handler; 
  5.     …… 
  6. } 

当然这个注册过程并不是只有这么一句话，看到这条语句，相信你应该知道什么意思了。在input的open函数执行之前，即我们的open代码打开之前，input_table中的字段已经被事件处理层填充了。由于evdev的次设备号在初始化的时候就设置成了64，因此这里相当于：

[cpp] view plain copy
  1. input_table[2]=&evdev_handler； 

回到input_open_file函数查看new_fops->open(inode, file)你便知道了调用的是:

[cpp] view plain copy
  1. evdev_handler.evdev_fops.open（inode, file）； 

在分析open函数之前，解释一下为什么要右移5位，这说明一个问题，次设备号的低5位被忽略，这说明evdev的最大支持的输入设备驱动个数为2^5次方等于32个，你可能会看到你的/dev目录下面有event0、event1、event2等设备，他们的次设备号分别为64、65、66等等。但最大是64+32-1，因此input_table为这些输入设备增加的一个统一接口，通过上层打开设备时，只要次设备号在64+32-1之间的设备都会重新定位到evdev_handler中，即event*设备打开后执行的底层函数将被重新定义到evdev_handler中。

相信上面的问题已经描述清楚，如果还是不明白，你最起码应该知道的是，input设备中的open函数只是一个接口，通过次设备号才找到了真正的事件处理接口。接下来要看新的open接口的实现了，evdev_handler-> fops->open实现如下：

[cpp] view plain copy
  1. /*evdev字符设备驱动接口 */ 
  2. static const struct file_operations evdev_fops = { 
  3.        .owner = THIS_MODULE, 
  4.        .read =           evdev_read, 
  5.        .write =   evdev_write, 
  6.        .poll =            evdev_poll, 
  7.        .open =          evdev_open, 
  8.        .release = evdev_release, 
  9.        .unlocked_ioctl = evdev_ioctl, 
  10. #ifdef CONFIG_COMPAT 
  11.        .compat_ioctl =      evdev_ioctl_compat, 
  12. #endif 
  13.        .fasync = evdev_fasync, 
  14.        .flush =   evdev_flush 
  15. }; 
  16. /*evdev设备open函数的实现过程 */ 
  17. static int evdev_open(struct inode *inode, struct file *file) 
  18. { 
  19.        struct evdev_client *client; 
  20.        struct evdev *evdev; 
  21.        /* 如果是event0，对于evdev设备来说，次设备号当然是0 */ 
  22.        int i = iminor(inode) - EVDEV_MINOR_BASE; 
  23.        int error; 
  24.        /* 如果大于32，说明超出了evdev能够容纳的最大输入设备个数 */ 
  25.        if (i >= EVDEV_MINORS) 
  26.               return -ENODEV; 
  27.        /* 由于evdev中能容纳32个输入设备，因此通过设备号event0中的0定位到是要处理的是哪一个输入设备，evdev_table中的内容在输入设备驱动注册时通过evdev_connect填充 */ 
  28.        evdev = evdev_table[i]; 
  29.        /* 判断是否设备接口存在，evdev_exist也是在evdev_connect填充为1 */ 
  30.        if (!evdev || !evdev->exist) 
  31.               return -ENODEV; 
  32.        /* 存在则分配evdev中的client来处理event* */ 
  33.        client = kzalloc(sizeof(struct evdev_client),GFP_KERNEL); 
  34.        if (!client) 
  35.               return -ENOMEM; 
  36.   
  37.        /* 把event*中的接口指向evdev_table中对应项 */ 
  38.        client->evdev = evdev; 
  39.        /* 把client->node链接到evdev子集中 */ 
  40.        list_add_tail(&client->node,&evdev->client_list); 
  41.        /* 如果open是第一个打开，则会执行input_open_device*/ 
  42.        if (!evdev->open++ &&evdev->exist) { 
  43.               error =input_open_device(&evdev->handle); 
  44.               if (error) { 
  45.                      list_del(&client->node); 
  46.                      kfree(client); 
  47.                      return error; 
  48.               } 
  49.        } 
  50.        /* 将file私有指针指向client*/ 
  51.        file->private_data = client; 
  52.        return 0; 
  53. } 
  54. 由上的代码可以看出，最终是要执行input_open_device去执行设备驱动程序中的代码，然而我们在定义设备驱动的时候并没有给input_dev中的open字段填充内容，因此可以看到input_open_device函数的执行过程： 
  55. if(!dev->users++ && dev->open) 
  56.               err = dev->open(dev); 
  57.   
  58.        if (err) 
  59.               handle->open--; 

上面截取了片段，并没有执行到open函数，open进行自减操作，表示没有调用过open，这个值主要是为了close中判断open为0时释放资源使用。

不仅如此，我们在触摸屏驱动中也没有定义read、write，那当触摸屏上报事件时，是如何处理的呢？我们需要先到触摸屏驱动程序中找到上报事件的函数再做进一步分析。

1.3    输入设备上报事件的处理过程

触摸屏驱动程序上报事件的函数为：

[cpp] view plain copy
  1. input_report_abs(dev,ABS_X, s3c2440_ts->tc.xp); 
  2. input_report_abs(dev,ABS_Y, s3c2440_ts->tc.yp); 
  3. input_report_abs(dev,ABS_PRESSURE, s3c2440_ts->tc.pressure); 
  4. input_report_key(dev,BTN_TOUCH, s3c2440_ts->pendown); 
  5. input_sync(dev); 

然而他们其实是input_event函数的封装，调用的都是input_event函数，这一函数在input.c中实现如下：

[cpp] view plain copy
  1. void input_event(struct input_dev *dev, unsigned int type, unsigned int code, intvalue) 
  2. { 
  3.        struct input_handle *handle; 
  4.   
  5.        if (type > EV_MAX || !test_bit(type,dev->evbit)) 
  6.               return; 
  7.        switch (type) { 
  8.               case EV_SYN: 
  9.                      switch (code) { 
  10.                             case SYN_CONFIG: 
  11.                                    if(dev->event) 
  12.                                           dev->event(dev,type, code, value); 
  13.                                    break; 
  14.                             case SYN_REPORT: 
  15.                                    if(dev->sync) 
  16.                                           return; 
  17.                                    dev->sync= 1; 
  18.                                    break; 
  19.                      } 
  20.                      break; 
  21.               case EV_KEY: 
  22.               case EV_SW: 
  23.               case EV_ABS: 
  24.               case EV_REL: 
  25.               case EV_MSC: 
  26.               case EV_LED: 
  27.               case EV_SND: 
  28.               case EV_REP: 
  29.               case EV_FF: 
  30.        } 
  31.   
  32.        if (type != EV_SYN) 
  33.               dev->sync = 0; 
  34.   
  35.        if (dev->grab) 
  36.               dev->grab->handler->event(dev->grab,type, code, value); 
  37.        else 
  38.               list_for_each_entry(handle,&dev->h_list, d_node) 
  39.                      if (handle->open) 
  40.                             handle->handler->event(handle,type, code, value); 
  41. } 

代码被做了精简，其中就是在匹配上报的事件，并根据事件的类型调用驱动程序中相应的函数来完成，但是由于我们并，没有定义过这些函数，因此执行最后的handle_handler_event函数，由事件处理层evdev_event函数来完成事件的保存工作，具体过程如下：

[cpp] view plain copy
  1. list_for_each_entry(client,&evdev->client_list, node) { 
  2. client->buffer[client->head].type= type; 
  3. client->buffer[client->head].code= code; 
  4. client->buffer[client->head].value= value; 
  5. client->head= (client->head + 1) & (EVDEV_BUFFER_SIZE - 1); 
  6. } 

这里列举了关键代码，即上报的事件被保存到了client_buffer中，其中client_buffer是一个循环缓冲区，client->head表示当前数据的位置，因此每次都写到client->head的位置，而读数据时需要到client_tail中读取。因为在open的时候，client已经被链入到了evdev->client_list中，因此通过可以通过list_for_each_entry重evdev->client_list中找到对应的client。

事件的上报都会把数据保存到client->buffer中，以便上层通过read和write进行读去和写入。

1.4    通过设备节点读取输入事件

还是以触摸屏驱动程序和evdev事件处理层驱动来分析：

[cpp] view plain copy
  1. static ssize_t evdev_read(struct file *file, char __user *buffer, size_t count, loff_t*ppos) 
  2. { 
  3.        struct evdev_client *client =file->private_data; 
  4.        struct evdev *evdev = client->evdev; 
  5.        int retval; 
  6.   
  7.        /* 判断用户给的count是否能够容纳事件数据的大小*/ 
  8.        if (count < evdev_event_size()) 
  9.               return -EINVAL; 
  10.   
  11.        /* 如果数据不为空并且设备存在并且是阻塞访问方式才能继续执行 */ 
  12.        if (client->head == client->tail&& evdev->exist && (file->f_flags & O_NONBLOCK)) 
  13.               return -EAGAIN; 
  14.   
  15.        /* 如果数据为空，设置进程等待底层驱动层上报事件到client->buffer中 */ 
  16.        retval =wait_event_interruptible(evdev->wait, 
  17.               client->head != client->tail|| !evdev->exist); 
  18.        if (retval) 
  19.               return retval; 
  20.   
  21.        if (!evdev->exist) 
  22.               return -ENODEV; 
  23.   
  24.        /* 循环读取数据 */ 
  25.        while (client->head != client->tail&& retval + evdev_event_size() <= count) { 
  26.   
  27.               struct input_event *event =(struct input_event *) client->buffer + client->tail; 
  28.   
  29.               if (evdev_event_to_user(buffer +retval, event)) 
  30.                      return -EFAULT; 
  31.   
  32.               client->tail = (client->tail+ 1) & (EVDEV_BUFFER_SIZE - 1); 
  33.               retval += evdev_event_size(); 
  34.        } 
  35.   
  36.        return retval; 
  37. } 

这里如果没有数据，进程会睡眠，那由谁来唤醒呢？细心的话可以发现，当设备驱动层调用input_event上报事件调用相应的event函数进行事件写入时，是会唤醒阻塞等待的进程的。

1.5    通过设备节点写入输入事件

写入过程：

[cpp] view plain copy
  1. static ssize_t evdev_write(struct file *file, const char __user *buffer, size_t count,loff_t *ppos) 
  2. { 
  3.        /* 循环写入，调用input_inject_event函数 */ 
  4.        while (retval < count) { 
  5.   
  6.               if (evdev_event_from_user(buffer +retval, &event)) 
  7.                      return -EFAULT; 
  8.               input_inject_event(&evdev->handle,event.type, event.code, event.value); 
  9.               retval += evdev_event_size(); 
  10.        } 
  11.   
  12.        return retval; 
  13. } 

上述代码中的event是input_event数组，包含了事件的类型、键值，通过input_inject_event把数据写入循环数组client->buffer中，input_inject_event调用的是input_event函数。

1.6    总结

本节对input子系统的整个过程做了分析，并从两个角度进行考虑，对于写输入设备驱动程序的来说，需要掌握的是设备应该上报事件的类型，这样才能匹配到对应的事件层驱动帮助你保存对应的数据，而对于设备上层开发者来说，应该先使用cat /proc/bus/input/devices查看你操作的设备类型和处理接口，以帮助你更好的对设备操作。

你可能感兴趣的:(linux input输入子系统分析《四》：input子系统整体流程全面分析)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 抖音乐买买怎么加入赚钱?赚钱方法是什么 测评君高省
    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 每日一题——第八十四题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
  • 2022-04-18 Apbenz
    语重心长的和我说，不要老是说不行，人至而立之年危机四伏，内在的，外在的，感觉就是心力憔悴，让人无所适从。面对职场的无情，突然好羡慕干体力劳动的外卖小哥。难道命运是想让我去送外卖了吗？干体力活才能让我活下去？fastadmin打卡成功,淘宝金币任务完成。ㅏㅓㅗㅜㅡㅣㅐㅔㅑㅕㅛㅠㅢㅒㅖY行。야자여자요리우유의사얘기예
  • 每日一题——第八十二题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
  • 每日一题——第八十三题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖 陟彼高冈yu 基于Googleearthstudio的旅游规划和预览旅游
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 我的黑历史 袖手围观有来有去
    孩子同学与我们一起共进晚餐，俩孩子加我三个人。小同学是一个大方率性礼貌的小孩，我们也都非常喜欢。好了，回到正题上来让我把这个故事讲完。俩孩子都喜欢吃鱼，所以就发生了小孩子之间常会发生的事。我狠狠的盯了我家孩子，孩子表情有些狼狈。和孩子单独一起的时候，见她尚未释怀，并谴责我不该狠盯她，让她没面子。也许是她触动了我的童年往事吧。由此，一狠心，给她讲了一段埋藏心里极深的黑历史：我奶奶有四个儿子，四个儿子
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！ 成长时间线
    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记 爱吃丸子的小樱桃
    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • 东南林氏之九牧林候选父系 祖缘树TheYtree
    渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • 2022现在哪个打车软件比较好用又便宜 实惠的打车软件合集 高省APP珊珊
    这是一个信息高速传播的社会。信息可以通过手机，微信，自媒体，抖音等方式进行传播。但同时这也是一个交通四通发达的社会。高省APP，是2022年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。珊珊导师，高省邀请码777777，注册送2皇冠会员，送万元推广大礼包，教你如何1年做到百万团队。高
  • libyuv之linux编译 jaronho Linuxlinux运维服务器
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
  • 走向以教育叙事为载体的教育叙事研究 666小飞鱼
    今天我读了吴松超老师的《给教师的68条建写作建议》中的第23条《如何通过教育叙事走向研究》，吴老师在文中与我们分享了一个德育案例，这是一个反面的案例，意在告知我们在处理问题时，不能就考虑的点太窄，思考要全面。走向教育叙事研究，教师要有敏锐的“感知力”，这个感知力来自于背后专业知识的支撑，思维能力以及广阔的视野和见识等。所以对于同一件事处理方法不同，这个就是教师背后“敏锐力”的不同造成的，也就是说是
  • HttpClient 4.3与4.3版本以下版本比较 spjich javahttpclient
    网上利用java发送http请求的代码很多，一搜一大把，有的利用的是java.net.*下的HttpURLConnection，有的用httpclient，而且发送的代码也分门别类。今天我们主要来说的是利用httpclient发送请求。 httpclient又可分为 httpclient3.x httpclient4.x到httpclient4.3以下 httpclient4.3
  • Essential Studio Enterprise Edition 2015 v1新功能体验 Axiba .net
    概述：Essential Studio已全线升级至2015 v1版本了！新版本为JavaScript和ASP.NET MVC添加了新的文件资源管理器控件，还有其他一些控件功能升级，精彩不容错过，让我们一起来看看吧！ syncfusion公司是世界领先的Windows开发组件提供商，该公司正式对外发布Essential Studio Enterprise Edition 2015 v1版本。新版本
  • [宇宙与天文]微波背景辐射值与地球温度 comsci 背景
            宇宙这个庞大,无边无际的空间是否存在某种确定的,变化的温度呢?      如果宇宙微波背景辐射值是表示宇宙空间温度的参数之一,那么测量这些数值,并观测周围的恒星能量输出值,我们是否获得地球的长期气候变化的情况呢?   &nbs
  • lvs-server 男人50 server
    #!/bin/bash # # LVS script for VS/DR # #./etc/rc.d/init.d/functions # VIP=10.10.6.252 RIP1=10.10.6.101 RIP2=10.10.6.13 PORT=80 case $1 in start)   /sbin/ifconfig eth2:0 $VIP broadca
  • java的WebCollector爬虫框架 oloz 爬虫
    WebCollector主页： https://github.com/CrawlScript/WebCollector 下载：webcollector-版本号-bin.zip将解压后文件夹中的所有jar包添加到工程既可。 接下来看demo package org.spider.myspider; import cn.edu.hfut.dmic.webcollector.cra
  • jQuery append 与 after 的区别 小猪猪08
    1、after函数 定义和用法： after() 方法在被选元素后插入指定的内容。 语法： $(selector).after(content) 实例： <html> <head> <script type="text/javascript" src="/jquery/jquery.js"></scr
  • mysql知识充电 香水浓 mysql
    索引 索引是在存储引擎中实现的，因此每种存储引擎的索引都不一定完全相同，并且每种存储引擎也不一定支持所有索引类型。 根据存储引擎定义每个表的最大索引数和最大索引长度。所有存储引擎支持每个表至少16个索引，总索引长度至少为256字节。 大多数存储引擎有更高的限制。MYSQL中索引的存储类型有两种：BTREE和HASH，具体和表的存储引擎相关； MYISAM和InnoDB存储引擎
  • 我的架构经验系列文章索引 agevs 架构
    下面是一些个人架构上的总结，本来想只在公司内部进行共享的，因此内容写的口语化一点，也没什么图示，所有内容没有查任何资料是脑子里面的东西吐出来的因此可能会不准确不全，希望抛砖引玉，大家互相讨论。 要注意，我这些文章是一个总体的架构经验不针对具体的语言和平台，因此也不一定是适用所有的语言和平台的。 （内容是前几天写的，现附上索引）   前端架构 http://www.
  • Android so lib库远程http下载和动态注册 aijuans andorid
    一、背景      在开发Android应用程序的实现，有时候需要引入第三方so lib库，但第三方so库比较大，例如开源第三方播放组件ffmpeg库, 如果直接打包的apk包里面, 整个应用程序会大很多.经过查阅资料和实验，发现通过远程下载so文件，然后再动态注册so文件时可行的。主要需要解决下载so文件存放位置以及文件读写权限问题。   二、主要
  • linux中svn配置出错 conf/svnserve.conf:12: Option expected 解决方法 baalwolf option
    在客户端访问subversion版本库时出现这个错误： svnserve.conf:12: Option expected 为什么会出现这个错误呢，就是因为subversion读取配置文件svnserve.conf时，无法识别有前置空格的配置文件，如### This file controls the configuration of the svnserve daemon, if you##
  • MongoDB的连接池和连接管理 BigCat2013 mongodb
    在关系型数据库中，我们总是需要关闭使用的数据库连接，不然大量的创建连接会导致资源的浪费甚至于数据库宕机。这篇文章主要想解释一下mongoDB的连接池以及连接管理机制，如果正对此有疑惑的朋友可以看一下。 通常我们习惯于new 一个connection并且通常在finally语句中调用connection的close()方法将其关闭。正巧，mongoDB中当我们new一个Mongo的时候，会发现它也
  • AngularJS使用Socket.IO bijian1013 JavaScriptAngularJSSocket.IO
            目前，web应用普遍被要求是实时web应用，即服务端的数据更新之后，应用能立即更新。以前使用的技术（例如polling）存在一些局限性，而且有时我们需要在客户端打开一个socket，然后进行通信。         Socket.IO(http://socket.io/)是一个非常优秀的库，它可以帮你实
  • [Maven学习笔记四]Maven依赖特性 bit1129 maven
    三个模块 为了说明问题，以用户登陆小web应用为例。通常一个web应用分为三个模块，模型和数据持久化层user-core, 业务逻辑层user-service以及web展现层user-web， user-service依赖于user-core user-web依赖于user-core和user-service   依赖作用范围  Maven的dependency定义
  • 【Akka一】Akka入门 bit1129 akka
    什么是Akka Message-Driven Runtime is the Foundation to Reactive Applications In Akka, your business logic is driven through message-based communication patterns that are independent of physical locatio
  • zabbix_api之perl语言写法 ronin47 zabbix_api之perl
    zabbix_api网上比较多的写法是python或curl。上次我用java－－http://bossr.iteye.com/blog/2195679，这次用perl。for example: #!/usr/bin/perl use 5.010 ; use strict ; use warnings ; use JSON :: RPC :: Client ; use
  • 比优衣库跟牛掰的视频流出了，兄弟连Linux运维工程师课堂实录，更加刺激，更加实在！ brotherlamp linux运维工程师linux运维工程师教程linux运维工程师视频linux运维工程师资料linux运维工程师自学
    比优衣库跟牛掰的视频流出了，兄弟连Linux运维工程师课堂实录，更加刺激，更加实在！   ----------------------------------------------------- 兄弟连Linux运维工程师课堂实录-计算机基础-1-课程体系介绍1 链接：http://pan.baidu.com/s/1i3GQtGL 密码：bl65   兄弟连Lin
  • bitmap求哈密顿距离-给定N（1<=N<=100000）个五维的点A(x1,x2,x3,x4,x5)，求两个点X(x1,x2,x3,x4,x5)和Y( bylijinnan java
    import java.util.Random; /** * 题目： * 给定N（1<=N<=100000）个五维的点A(x1,x2,x3,x4,x5)，求两个点X(x1,x2,x3,x4,x5)和Y(y1,y2,y3,y4,y5)， * 使得他们的哈密顿距离（d=|x1-y1| + |x2-y2| + |x3-y3| + |x4-y4| + |x5-y5|）最大
  • map的三种遍历方法 chicony map
    package com.test; import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class TestMap { public static v
  • Linux安装mysql的一些坑 chenchao051 linux
    1、mysql不建议在root用户下运行   2、出现服务启动不了，111错误，注意要用chown来赋予权限， 我在root用户下装的mysql，我就把usr/share/mysql/mysql.server复制到/etc/init.d/mysqld, (同时把my-huge.cnf复制/etc/my.cnf)  chown -R cc /etc/init.d/mysql
  • Sublime Text 3 配置 daizj 配置Sublime Text
    Sublime Text 3 配置解释(默认){// 设置主题文件“color_scheme”: “Packages/Color Scheme – Default/Monokai.tmTheme”,// 设置字体和大小“font_face”: “Consolas”,“font_size”: 12,// 字体选项：no_bold不显示粗体字，no_italic不显示斜体字，no_antialias和
  • MySQL server has gone away 问题的解决方法 dcj3sjt126com SQL Server
    MySQL server has gone away 问题解决方法，需要的朋友可以参考下。 应用程序（比如PHP）长时间的执行批量的MYSQL语句。执行一个SQL，但SQL语句过大或者语句中含有BLOB或者longblob字段。比如，图片数据的处理。都容易引起MySQL server has gone away。 今天遇到类似的情景，MySQL只是冷冷的说：MySQL server h
  • javascript/dom:固定居中效果 dcj3sjt126com JavaScript
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&
  • 使用 Spring 2.5 注释驱动的 IoC 功能 e200702084 springbean配置管理IOCOffice
    使用 Spring 2.5 注释驱动的 IoC 功能 developerWorks 文档选项 将打印机的版面设置成横向打印模式 打印本页 将此页作为电子邮件发送 将此页作为电子邮件发送 级别： 初级 陈 雄华 ([email protected]), 技术总监, 宝宝淘网络科技有限公司 2008 年 2 月 28 日  &nb
  • MongoDB常用操作命令 geeksun mongodb
    1.   基本操作 db.AddUser(username,password)               添加用户 db.auth(usrename,password)      设置数据库连接验证 db.cloneDataBase(fromhost)    
  • php写守护进程（Daemon） hongtoushizi PHP
    转载自： http://blog.csdn.net/tengzhaorong/article/details/9764655   守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。守护进程是一种很有用的进程。php也可以实现守护进程的功能。   1、基本概念   &nbs
  • spring整合mybatis,关于注入Dao对象出错问题 jonsvien DAOspringbeanmybatisprototype
    今天在公司测试功能时发现一问题： 先进行代码说明： 1，controller配置了Scope="prototype"（表明每一次请求都是原子型）    @resource/@autowired service对象都可以（两种注解都可以）。 2，service 配置了Scope="prototype"（表明每一次请求都是原子型）
  • 对象关系行为模式之标识映射 home198979 PHP架构企业应用对象关系标识映射
    HELLO!架构   一、概念 identity Map:通过在映射中保存每个已经加载的对象，确保每个对象只加载一次，当要访问对象的时候，通过映射来查找它们。其实在数据源架构模式之数据映射器代码中有提及到标识映射，Mapper类的getFromMap方法就是实现标识映射的实现。     二、为什么要使用标识映射？ 在数据源架构模式之数据映射器中 //c
  • Linux下hosts文件详解 pda158 linux
    　1、主机名： 　　无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。 　　公网：IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。 　　局域网：每台机器都有一个主机名，用于主机与主机之间的便于区分，就可以为每台机器设置主机
  • nginx配置文件粗解 spjich javanginx
    #运行用户#user  nobody;#启动进程,通常设置成和cpu的数量相等worker_processes  2;#全局错误日志及PID文件#error_log  logs/error.log;#error_log  logs/error.log  notice;#error_log  logs/error.log  inf
  • 数学函数 w54653520 java
    public  class  S {        // 传入两个整数，进行比较，返回两个数中的最大值的方法。      public  int  get( int  num1, int  nu
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他