drm_compositor_create // 创建compositor
  udev_input_init // input初始化
    udev_input_enable
      udev_input_add_devices
        device_added // 从input设备对应的uevent中读取udevnode，并将其加入到epoll监控中
          evdev_device_create
            wl_event_loop_add_fd
              add_source // 实际将input设备对应的fd加入到epoll监控中

struct evdev_device *
evdev_device_create(struct weston_seat *seat, const char *path, int device_fd)
{
  ...
  // device_fd是通过udev从相应设备中读取的，对应于/dev/input/eventx设备的fd
  device->fd = device_fd;
  ...
  // 获取设备名称
	ioctl(device->fd, EVIOCGNAME(sizeof(devname)), devname);
	devname[sizeof(devname) - 1] = '\0';
	device->devname = strdup(devname);

	if (evdev_configure_device(device) == -1)
		goto err;

	if (device->seat_caps == 0) {
		evdev_device_destroy(device);
		return EVDEV_UNHANDLED_DEVICE;
	}
  //创建dispatch，后续在事件循环中使用
	/* If the dispatch was not set up use the fallback. */
	if (device->dispatch == NULL)
		device->dispatch = fallback_dispatch_create();
	if (device->dispatch == NULL)
		goto err;
  //将input设备对应的fd加入到epoll监控中，并设置事件发生时的处理接口为evdev_device_data(后面说明)
	device->source = wl_event_loop_add_fd(ec->input_loop, device->fd,
					      WL_EVENT_READABLE,
					      evdev_device_data, device);
	...
}

static struct wl_event_source *
add_source(struct wl_event_loop *loop,
	   struct wl_event_source *source, uint32_t mask, void *data)
{
  struct epoll_event ep;
  ...
	// 初始化事件类型，前面传入的mask为WL_EVENT_READABLE，所以这里设置的event类型应该时EPOLLIN，即当设备上有“输入”事件时，唤醒处理
	memset(&ep, 0, sizeof ep);
	if (mask & WL_EVENT_READABLE)
		ep.events |= EPOLLIN;
	if (mask & WL_EVENT_WRITABLE)
		ep.events |= EPOLLOUT;
	ep.data.ptr = source;
  // 通过epoll_ctl接口将input设备对应的fd加入到监控列表中
	if (epoll_ctl(loop->epoll_fd, EPOLL_CTL_ADD, source->fd, &ep) < 0) {
		close(source->fd);
		free(source);
		return NULL;
	}
  ...
}

evdev_device_data // 入口
  evdev_process_events // 调用前面evdev_device_create中创建的dispatch中的相应接口，设置为fallback_process
    fallback_process // 根据事件类型(比如，鼠标移动、键盘按键)选择相应的事件处理，键盘按键走evdev_process_key
      evdev_process_key
        notify_key // 通知client按键事件
          update_modifier_state // 更新modifier状态，capslock需要更新相应的lock modifier
            xkb_state_update_key // 使用libxkbcommon接口更新相应的modifier
              xkb_filter_apply_all

struct evdev_dispatch_interface fallback_interface = {
  fallback_process,
  fallback_destroy
};

/**
 * Applies any relevant filters to the key, first from the list of filters
 * that are currently active, then if no filter has claimed the key, possibly
 * apply a new filter from the key action.
 */
static void
xkb_filter_apply_all(struct xkb_state *state,
                     const struct xkb_key *key,
                     enum xkb_key_direction direction)
{
    // 抽象了一个filter概念，其中包含关键接口func，用于实际执行filter操作，即修改modifier。
    struct xkb_filter *filter;
    const union xkb_action *action;
    bool send = true;

    /* First run through all the currently active filters and see if any of
     * them have claimed this event. */
    /* 遍历现有的所有filter确认其func是否已经初始化，需要注意：filter的func是在后面
     * 的代码中初始化的，实际是在按键(如capslock)按下之后，即在按键按下之后这里代码不会
     * 执行，只有在按键弹起后才会执行到这里。
     */
    darray_foreach(filter, state->filters) {
        if (!filter->func)
            continue;
        send = filter->func(state, filter, key, direction) && send;
    }
    /* 判断当前按键状态，XKB_KEY_UP表示按键弹起，即按键弹起时，不进行后面的操作，仅执行
     * 前面的filter->func; 当按键按下时执行后面的流程
     */
    if (!send || direction == XKB_KEY_UP)
        return;
    // Xkb扩展协议中规范了每个按键事件的执行流程，其中一个步骤就是执行每个按键对应的action
    action = xkb_key_get_action(state, key);

    // 这里开始初始化filter
    filter = xkb_filter_new(state);
    if (!filter)
        return; /* WSGO */

    filter->key = key;
    // 设置filter->func，从filter_action_funcs中读取，该接口中实际实现了lock modifier修改。后面单独分析
    filter->func = filter_action_funcs[action->type].func;
    filter->action = *action;
    // 调用filter_action_funcs中定义的new接口，其中设置了setmods，后面单独分析
    filter_action_funcs[action->type].new(state, filter);
}

static void
xkb_filter_mod_lock_new(struct xkb_state *state, struct xkb_filter *filter)
{
    filter->priv = (state->components.locked_mods &
                    filter->action.mods.mods.mask);
    // 设置set_mods，在上级函数xkb_state_update_key中会根据该标记，设置base modifier
    state->set_mods |= filter->action.mods.mods.mask;
    if (!(filter->action.mods.flags & ACTION_LOCK_NO_LOCK))
        // 设置lock modifier
        state->components.locked_mods |= filter->action.mods.mods.mask;
}

static bool
xkb_filter_mod_lock_func(struct xkb_state *state,
                         struct xkb_filter *filter,
                         const struct xkb_key *key,
                         enum xkb_key_direction direction)
{
    ...
    // 设置clear_mods，其上级函数xkb_state_update_key中会根据该标记，清理base modifier
    state->clear_mods |= filter->action.mods.mods.mask;
    if (!(filter->action.mods.flags & ACTION_LOCK_NO_UNLOCK))
        // 根据之前的状态设置locked_mods
        state->components.locked_mods &= ~filter->priv;
    // 按键释放后清除filter->func
    filter->func = NULL;
    return true;
}

static void evdev_pass_values(struct evdev_client *client,
			const struct input_value *vals, unsigned int count,
			ktime_t *ev_time)
{
  ...
	for (v = vals; v != vals + count; v++) {
		event.type = v->type;
		event.code = v->code;
		event.value = v->value;
    // 其中调用kill_fasync，向用户态进程发送SIGIO信号，其它的文章中已经分析过了
		__pass_event(client, &event);
		if (v->type == EV_SYN && v->code == SYN_REPORT)
			wakeup = true;
	}
  ...
	if (wakeup)
    // 唤醒wait队列
		wake_up_interruptible(&evdev->wait);
}