evdev: Support device hotplug with udev

ui/events/ozone/evdev/event_factory.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/events/ozone/evdev/event_factory.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/input.h>
 #include <poll.h>
@@ skipping 25 matching lines @@
   return devinfo.HasKeyEvent(BTN_LEFT) || devinfo.HasKeyEvent(BTN_MIDDLE) ||
          devinfo.HasKeyEvent(BTN_RIGHT) || devinfo.HasKeyEvent(BTN_TOOL_FINGER);
 }
 
 bool IsTouchScreen(const EventDeviceInfo& devinfo) {
   return devinfo.HasEventType(EV_ABS) && !IsTouchPad(devinfo);
 }
 
 #if defined(USE_UDEV)
 
+const char kSubsystemInput[] = "input";
+
 // Severity levels from syslog.h. We can't include it directly as it
 // conflicts with base/logging.h
 enum {
   SYS_LOG_EMERG = 0,
   SYS_LOG_ALERT = 1,
   SYS_LOG_CRIT = 2,
   SYS_LOG_ERR = 3,
   SYS_LOG_WARNING = 4,
   SYS_LOG_NOTICE = 5,
   SYS_LOG_INFO = 6,
@@ skipping 21 matching lines @@
 // Connect to the udev daemon.
 scoped_udev UdevConnect() {
   struct udev* udev = udev_new();
   if (udev) {
     udev_set_log_fn(udev, UdevLog);
     udev_set_log_priority(udev, SYS_LOG_DEBUG);
   }
   return scoped_udev(udev);
 }
 
+// Start monitoring input device changes.
+scoped_udev_monitor UdevCreateMonitor(struct udev* udev) {
+  struct udev_monitor* monitor = udev_monitor_new_from_netlink(udev, "udev");
+  if (monitor) {
+    udev_monitor_filter_add_match_subsystem_devtype(
+        monitor, kSubsystemInput, NULL);
+
+    if (udev_monitor_enable_receiving(monitor))
+      LOG(ERROR) << "failed to start receiving events from udev";
+  }
+
+  return scoped_udev_monitor(monitor);
+}
+
 // Enumerate all input devices using udev. Calls device_callback per device.
 bool UdevEnumerateInputDevices(
     struct udev* udev,
     base::Callback<void(const base::FilePath&)> device_callback) {
   scoped_udev_enumerate enumerate(udev_enumerate_new(udev));
   if (!enumerate)
     return false;
 
-  udev_enumerate_add_match_subsystem(enumerate.get(), "input");
+  udev_enumerate_add_match_subsystem(enumerate.get(), kSubsystemInput);
   udev_enumerate_scan_devices(enumerate.get());
 
   struct udev_list_entry* devices =
       udev_enumerate_get_list_entry(enumerate.get());
   struct udev_list_entry* entry;
 
   udev_list_entry_foreach(entry, devices) {
     const char* name = udev_list_entry_get_name(entry);
 
     scoped_udev_device device(udev_device_new_from_syspath(udev, name));
     if (!device)
       continue;
 
     const char* path = udev_device_get_devnode(device.get());
     if (!path)
       continue;
 
     // Found input device node; attach.
     device_callback.Run(base::FilePath(path));
   }
 
   return true;
 }
 
 #endif  // defined(USE_UDEV)
 
 }  // namespace
 
+#if defined(USE_UDEV)
+
+typedef base::Callback<void(const base::FilePath&)> DeviceCallback;
+
+// Watcher class for input device changes.
+//
+// This monitors the udev netlink socket with MessagePumpLibevent and turns
+// the device change events into callbacks.
+//
+// The udev monitor should already be configured to filter the events
+// and enabled. This class only deals with IO from the socket.
+class UdevWatcher : public base::MessagePumpLibevent::Watcher {
+ public:
+  UdevWatcher(struct udev_monitor* monitor,
+              DeviceCallback device_added,
+              DeviceCallback device_removed)
+      : monitor_(monitor),
+        device_added_(device_added),
+        device_removed_(device_removed) {}
+
+  ~UdevWatcher() { Stop(); }
+
+  // Start watching the socket.
+  bool Start() {
+    int fd = udev_monitor_get_fd(monitor_);
+    if (fd < 0)
+      return false;
+
+    return base::MessagePumpOzone::Current()->WatchFileDescriptor(
+        fd, true, base::MessagePumpLibevent::WATCH_READ, &controller_, this);
+  }
+
+  // Stop watching the socket.
+  void Stop() { controller_.StopWatchingFileDescriptor(); }
+
+  void OnFileCanReadWithoutBlocking(int fd) OVERRIDE {
+    // The netlink socket should never become disconnected. There's no need
+    // to handle broken connections here.
+
+    scoped_udev_device device(udev_monitor_receive_device(monitor_));
+    if (!device)
+      return;
+
+    const char* path = udev_device_get_devnode(device.get());
+    const char* action = udev_device_get_action(device.get());
+    if (!path || !action)
+      return;
+
+    if (!strcmp(action, "add") || !strcmp(action, "change"))
+      device_added_.Run(base::FilePath(path));
+    else if (!strcmp(action, "remove"))
+      device_removed_.Run(base::FilePath(path));
+  }
+
+  void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE { NOTREACHED(); }
+
+ private:
+  struct udev_monitor* monitor_;
+  base::MessagePumpLibevent::FileDescriptorWatcher controller_;
+
+  // Callbacks for device changes.
+  DeviceCallback device_added_;
+  DeviceCallback device_removed_;
+};
+
+#endif  // defined(USE_UDEV)
+
 EventFactoryEvdev::EventFactoryEvdev() {}
 
-EventFactoryEvdev::~EventFactoryEvdev() { STLDeleteValues(&converters_); }
+EventFactoryEvdev::~EventFactoryEvdev() {
+#if defined(USE_UDEV)
+  if (watcher_)
+    watcher_->Stop();
+#endif
+  STLDeleteValues(&converters_);
+}
 
 void EventFactoryEvdev::AttachInputDevice(const base::FilePath& path) {
   TRACE_EVENT1("ozone", "AttachInputDevice", "path", path.value());
 
   int fd = open(path.value().c_str(), O_RDONLY | O_NONBLOCK);
   if (fd < 0) {
     PLOG(ERROR) << "Cannot open '" << path.value();
     return;
   }
 
   EventDeviceInfo devinfo;
   if (!devinfo.Initialize(fd)) {
     LOG(ERROR) << "failed to get device information for " << path.value();
     close(fd);
     return;
   }
 
   if (IsTouchPad(devinfo)) {
     LOG(WARNING) << "touchpad device not supported: " << path.value();
     close(fd);
     return;
   }
 
-  // TODO(spang) Add more device types. Support hot-plugging.
+  // TODO(spang) Add more device types.
   scoped_ptr<EventConverterEvdev> converter;
   if (IsTouchScreen(devinfo))
     converter.reset(new TouchEventConverterEvdev(fd, path));
   else if (devinfo.HasEventType(EV_KEY))
     converter.reset(new KeyEventConverterEvdev(fd, path, &modifiers_));
 
   if (converter) {
+    delete converters_[path];
     converters_[path] = converter.release();

[sadrul, 2014/01/30 22:10:36]

Can we store scoped_ptr<>s in converters_?

[spang, 2014/01/31 17:33:00]

Don't think so. scoped_ptr<> is not copyable and so can't be used in STL
containers.

[sadrul, 2014/01/31 21:00:59]

It looks like we have one std::map that stores scoped_ptr<>s (in
win8/metro_driver/chrome_app_view.h). If we can use something like that here,
that would be great, because it looks like an easy to thing to forget to
explicitly delete

[spang, 2014/01/31 22:02:07]

It is easy to forget, and I'm not super happy with this either. This seems to be
the usual style, though - there's 600 call sites for STLDelete[...] in the tree.

That win8 example seems suspect. scoped_ptr<> does not meet the preconditions
for std::map and trying does not even compile with gcc.

   } else {
     close(fd);
   }
 }
 
+void EventFactoryEvdev::DetachInputDevice(const base::FilePath& path) {
+  TRACE_EVENT1("ozone", "DetachInputDevice", "path", path.value());
+  delete converters_[path];
+  converters_.erase(path);
+}
+
 void EventFactoryEvdev::StartProcessingEvents() {
-  base::ThreadRestrictions::AssertIOAllowed();
-
 #if defined(USE_UDEV)
   // Scan for input devices using udev.
   StartProcessingEventsUdev();
 #else
   // No udev support. Scan devices manually in /dev/input.
   StartProcessingEventsManual();
 #endif
 }
 
 void EventFactoryEvdev::StartProcessingEventsManual() {
   base::FileEnumerator file_enum(base::FilePath("/dev/input"),
                                  false,
                                  base::FileEnumerator::FILES,
                                  "event*[0-9]");
   for (base::FilePath path = file_enum.Next(); !path.empty();
        path = file_enum.Next())
     AttachInputDevice(path);
 }
 
 #if defined(USE_UDEV)
 void EventFactoryEvdev::StartProcessingEventsUdev() {
   udev_ = UdevConnect();
   if (!udev_) {
     LOG(ERROR) << "failed to connect to udev";
     return;
   }
+  if (!StartMonitoringDevicesUdev())
+    LOG(ERROR) << "failed to start monitoring device changes via udev";
   if (!UdevEnumerateInputDevices(
            udev_.get(),
            base::Bind(&EventFactoryEvdev::AttachInputDevice,
                       base::Unretained(this))))
     LOG(ERROR) << "failed to enumerate input devices via udev";
 }
-#endif
+
+bool EventFactoryEvdev::StartMonitoringDevicesUdev() {
+  udev_monitor_ = UdevCreateMonitor(udev_.get());
+  if (!udev_monitor_)
+    return false;
+
+  watcher_.reset(new UdevWatcher(
+      udev_monitor_.get(),
+      base::Bind(&EventFactoryEvdev::AttachInputDevice, base::Unretained(this)),
+      base::Bind(&EventFactoryEvdev::DetachInputDevice,
+                 base::Unretained(this))));
+  return watcher_->Start();
+}
+
+#endif  // defined(USE_UDEV)
 
 }  // namespace ui