os/inputthread.c

   1 /* inputthread.c -- Threaded generation of input events.
   2  *
   3  * Copyright © 2007-2008 Tiago Vignatti <vignatti at freedesktop org>
   4  * Copyright © 2010 Nokia
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors: Fernando Carrijo <fcarrijo at freedesktop org>
  25  *          Tiago Vignatti <vignatti at freedesktop org>
  26  */
  27
  28 #include <dix-config.h>
  29
  30 #include <stdio.h>
  31 #include <errno.h>
  32 #include <stdlib.h>
  33 #include <unistd.h>
  34 #include <pthread.h>
  35
  36 #include "dix/input_priv.h"
  37 #include "os/ddx_priv.h"
  38
  39 #include "inputstr.h"
  40 #include "opaque.h"
  41 #include "osdep.h"
  42
  43 #if INPUTTHREAD
  44
  45 Bool InputThreadEnable = TRUE;
  46
  47 /**
  48  * An input device as seen by the threaded input facility
  49  */
  50
  51 typedef enum _InputDeviceState {
  52     device_state_added,
  53     device_state_running,
  54     device_state_removed
  55 } InputDeviceState;
  56
  57 typedef struct _InputThreadDevice {
  58     struct xorg_list node;
  59     NotifyFdProcPtr readInputProc;
  60     void *readInputArgs;
  61     int fd;
  62     InputDeviceState state;
  63 } InputThreadDevice;
  64
  65 /**
  66  * The threaded input facility.
  67  *
  68  * For now, we have one instance for all input devices.
  69  */
  70 typedef struct {
  71     pthread_t thread;
  72     struct xorg_list devs;
  73     struct ospoll *fds;
  74     int readPipe;
  75     int writePipe;
  76     Bool changed;
  77     Bool running;
  78 } InputThreadInfo;
  79
  80 static InputThreadInfo *inputThreadInfo;
  81
  82 static int hotplugPipeRead = -1;
  83 static int hotplugPipeWrite = -1;
  84
  85 static int input_mutex_count;
  86
  87 #ifdef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
  88 static pthread_mutex_t input_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
  89 #else
  90 static pthread_mutex_t input_mutex;
  91 static Bool input_mutex_initialized;
  92 #endif
  93
  94 int
  95 in_input_thread(void)
  96 {
  97     return inputThreadInfo &&
  98            pthread_equal(pthread_self(), inputThreadInfo->thread);
  99 }
 100
 101 void
 102 input_lock(void)
 103 {
 104 #ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
 105     if (!input_mutex_initialized) {
 106         pthread_mutexattr_t mutex_attr;
 107
 108         input_mutex_initialized = TRUE;
 109         pthread_mutexattr_init(&mutex_attr);
 110         pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE);
 111         pthread_mutex_init(&input_mutex, &mutex_attr);
 112     }
 113 #endif
 114     pthread_mutex_lock(&input_mutex);
 115     ++input_mutex_count;
 116 }
 117
 118 void
 119 input_unlock(void)
 120 {
 121     --input_mutex_count;
 122     pthread_mutex_unlock(&input_mutex);
 123 }
 124
 125 void
 126 input_force_unlock(void)
 127 {
 128     if (pthread_mutex_trylock(&input_mutex) == 0) {
 129         input_mutex_count++;
 130         /* unlock +1 times for the trylock */
 131         while (input_mutex_count > 0)
 132             input_unlock();
 133     }
 134 }
 135
 136 /**
 137  * Notify a thread about the availability of new asynchronously enqueued input
 138  * events.
 139  *
 140  * @see WaitForSomething()
 141  */
 142 static void
 143 InputThreadFillPipe(int writeHead)
 144 {
 145     int ret;
 146     char byte = 0;
 147
 148     do {
 149         ret = write(writeHead, &byte, 1);
 150     } while (ret < 0 && ETEST(errno));
 151 }
 152
 153 /**
 154  * Consume eventual notifications left by a thread.
 155  *
 156  * @see WaitForSomething()
 157  * @see InputThreadFillPipe()
 158  */
 159 static int
 160 InputThreadReadPipe(int readHead)
 161 {
 162     int ret, array[10];
 163
 164     ret = read(readHead, &array, sizeof(array));
 165     if (ret >= 0)
 166         return ret;
 167
 168     if (errno != EAGAIN)
 169         FatalError("input-thread: draining pipe (%d)", errno);
 170
 171     return 1;
 172 }
 173
 174 static void
 175 InputReady(int fd, int xevents, void *data)
 176 {
 177     InputThreadDevice *dev = data;
 178
 179     input_lock();
 180     if (dev->state == device_state_running)
 181         dev->readInputProc(fd, xevents, dev->readInputArgs);
 182     input_unlock();
 183 }
 184
 185 /**
 186  * Register an input device in the threaded input facility
 187  *
 188  * @param fd File descriptor which identifies the input device
 189  * @param readInputProc Procedure used to read input from the device
 190  * @param readInputArgs Arguments to be consumed by the above procedure
 191  *
 192  * return 1 if success; 0 otherwise.
 193  */
 194 int
 195 InputThreadRegisterDev(int fd,
 196                        NotifyFdProcPtr readInputProc,
 197                        void *readInputArgs)
 198 {
 199     InputThreadDevice *dev, *old;
 200
 201     if (!inputThreadInfo)
 202         return SetNotifyFd(fd, readInputProc, X_NOTIFY_READ, readInputArgs);
 203
 204     input_lock();
 205
 206     dev = NULL;
 207     xorg_list_for_each_entry(old, &inputThreadInfo->devs, node) {
 208         if (old->fd == fd && old->state != device_state_removed) {
 209             dev = old;
 210             break;
 211         }
 212     }
 213
 214     if (dev) {
 215         dev->readInputProc = readInputProc;
 216         dev->readInputArgs = readInputArgs;
 217     } else {
 218         dev = calloc(1, sizeof(InputThreadDevice));
 219         if (dev == NULL) {
 220             DebugF("input-thread: could not register device\n");
 221             input_unlock();
 222             return 0;
 223         }
 224
 225         dev->fd = fd;
 226         dev->readInputProc = readInputProc;
 227         dev->readInputArgs = readInputArgs;
 228         dev->state = device_state_added;
 229
 230         /* Do not prepend, so that any dev->state == device_state_removed
 231          * with the same dev->fd get processed first. */
 232         xorg_list_append(&dev->node, &inputThreadInfo->devs);
 233     }
 234
 235     inputThreadInfo->changed = TRUE;
 236
 237     input_unlock();
 238
 239     DebugF("input-thread: registered device %d\n", fd);
 240     InputThreadFillPipe(hotplugPipeWrite);
 241
 242     return 1;
 243 }
 244
 245 /**
 246  * Unregister a device in the threaded input facility
 247  *
 248  * @param fd File descriptor which identifies the input device
 249  *
 250  * @return 1 if success; 0 otherwise.
 251  */
 252 int
 253 InputThreadUnregisterDev(int fd)
 254 {
 255     InputThreadDevice *dev;
 256     Bool found_device = FALSE;
 257
 258     /* return silently if input thread is already finished (e.g., at
 259      * DisableDevice time, evdev tries to call this function again through
 260      * xf86RemoveEnabledDevice) */
 261     if (!inputThreadInfo) {
 262         RemoveNotifyFd(fd);
 263         return 1;
 264     }
 265
 266     input_lock();
 267     xorg_list_for_each_entry(dev, &inputThreadInfo->devs, node)
 268         if (dev->fd == fd) {
 269             found_device = TRUE;
 270             break;
 271         }
 272
 273     /* fd didn't match any registered device. */
 274     if (!found_device) {
 275         input_unlock();
 276         return 0;
 277     }
 278
 279     dev->state = device_state_removed;
 280     inputThreadInfo->changed = TRUE;
 281
 282     input_unlock();
 283
 284     InputThreadFillPipe(hotplugPipeWrite);
 285     DebugF("input-thread: unregistered device: %d\n", fd);
 286
 287     return 1;
 288 }
 289
 290 static void
 291 InputThreadPipeNotify(int fd, int revents, void *data)
 292 {
 293     /* Empty pending input, shut down if the pipe has been closed */
 294     if (InputThreadReadPipe(hotplugPipeRead) == 0) {
 295         inputThreadInfo->running = FALSE;
 296     }
 297 }
 298
 299 /**
 300  * The workhorse of threaded input event generation.
 301  *
 302  * Or if you prefer: The WaitForSomething for input devices. :)
 303  *
 304  * Runs in parallel with the server main thread, listening to input devices in
 305  * an endless loop. Whenever new input data is made available, calls the
 306  * proper device driver's routines which are ultimately responsible for the
 307  * generation of input events.
 308  *
 309  * @see InputThreadPreInit()
 310  * @see InputThreadInit()
 311  */
 312
 313 static void*
 314 InputThreadDoWork(void *arg)
 315 {
 316     sigset_t set;
 317
 318     /* Don't handle any signals on this thread */
 319     sigfillset(&set);
 320     pthread_sigmask(SIG_BLOCK, &set, NULL);
 321
 322     ddxInputThreadInit();
 323
 324     inputThreadInfo->running = TRUE;
 325
 326 #if defined(HAVE_PTHREAD_SETNAME_NP_WITH_TID)
 327     pthread_setname_np (pthread_self(), "InputThread");
 328 #elif defined(HAVE_PTHREAD_SETNAME_NP_WITHOUT_TID)
 329     pthread_setname_np ("InputThread");
 330 #endif
 331
 332     ospoll_add(inputThreadInfo->fds, hotplugPipeRead,
 333                ospoll_trigger_level,
 334                InputThreadPipeNotify,
 335                NULL);
 336     ospoll_listen(inputThreadInfo->fds, hotplugPipeRead, X_NOTIFY_READ);
 337
 338     while (inputThreadInfo->running)
 339     {
 340         DebugF("input-thread: %s waiting for devices\n", __func__);
 341
 342         /* Check for hotplug changes and modify the ospoll structure to suit */
 343         if (inputThreadInfo->changed) {
 344             InputThreadDevice *dev, *tmp;
 345
 346             input_lock();
 347             inputThreadInfo->changed = FALSE;
 348             xorg_list_for_each_entry_safe(dev, tmp, &inputThreadInfo->devs, node) {
 349                 switch (dev->state) {
 350                 case device_state_added:
 351                     ospoll_add(inputThreadInfo->fds, dev->fd,
 352                                ospoll_trigger_level,
 353                                InputReady,
 354                                dev);
 355                     ospoll_listen(inputThreadInfo->fds, dev->fd, X_NOTIFY_READ);
 356                     dev->state = device_state_running;
 357                     break;
 358                 case device_state_running:
 359                     break;
 360                 case device_state_removed:
 361                     ospoll_remove(inputThreadInfo->fds, dev->fd);
 362                     xorg_list_del(&dev->node);
 363                     free(dev);
 364                     break;
 365                 }
 366             }
 367             input_unlock();
 368         }
 369
 370         if (ospoll_wait(inputThreadInfo->fds, -1) < 0) {
 371             if (errno == EINVAL)
 372                 FatalError("input-thread: %s (%s)", __func__, strerror(errno));
 373             else if (errno != EINTR)
 374                 ErrorF("input-thread: %s (%s)\n", __func__, strerror(errno));
 375         }
 376
 377         /* Kick main thread to process the generated input events and drain
 378          * events from hotplug pipe */
 379         InputThreadFillPipe(inputThreadInfo->writePipe);
 380     }
 381
 382     ospoll_remove(inputThreadInfo->fds, hotplugPipeRead);
 383
 384     return NULL;
 385 }
 386
 387 static void
 388 InputThreadNotifyPipe(int fd, int mask, void *data)
 389 {
 390     InputThreadReadPipe(fd);
 391 }
 392
 393 /**
 394  * Pre-initialize the facility used for threaded generation of input events
 395  *
 396  */
 397 void
 398 InputThreadPreInit(void)
 399 {
 400     int fds[2], hotplugPipe[2];
 401     int flags;
 402
 403     if (!InputThreadEnable)
 404         return;
 405
 406     if (pipe(fds) < 0)
 407         FatalError("input-thread: could not create pipe");
 408
 409      if (pipe(hotplugPipe) < 0)
 410         FatalError("input-thread: could not create pipe");
 411
 412     inputThreadInfo = malloc(sizeof(InputThreadInfo));
 413     if (!inputThreadInfo)
 414         FatalError("input-thread: could not allocate memory");
 415
 416     inputThreadInfo->changed = FALSE;
 417
 418     inputThreadInfo->thread = 0;
 419     xorg_list_init(&inputThreadInfo->devs);
 420     inputThreadInfo->fds = ospoll_create();
 421
 422     /* By making read head non-blocking, we ensure that while the main thread
 423      * is busy servicing client requests, the dedicated input thread can work
 424      * in parallel.
 425      */
 426     inputThreadInfo->readPipe = fds[0];
 427     fcntl(inputThreadInfo->readPipe, F_SETFL, O_NONBLOCK);
 428     flags = fcntl(inputThreadInfo->readPipe, F_GETFD);
 429     if (flags != -1) {
 430         flags |= FD_CLOEXEC;
 431         (void)fcntl(inputThreadInfo->readPipe, F_SETFD, flags);
 432     }
 433     SetNotifyFd(inputThreadInfo->readPipe, InputThreadNotifyPipe, X_NOTIFY_READ, NULL);
 434
 435     inputThreadInfo->writePipe = fds[1];
 436
 437     hotplugPipeRead = hotplugPipe[0];
 438     fcntl(hotplugPipeRead, F_SETFL, O_NONBLOCK);
 439     flags = fcntl(hotplugPipeRead, F_GETFD);
 440     if (flags != -1) {
 441         flags |= FD_CLOEXEC;
 442         (void)fcntl(hotplugPipeRead, F_SETFD, flags);
 443     }
 444     hotplugPipeWrite = hotplugPipe[1];
 445
 446 #ifndef __linux__ /* Linux does not deal well with renaming the main thread */
 447 #if defined(HAVE_PTHREAD_SETNAME_NP_WITH_TID)
 448     pthread_setname_np (pthread_self(), "MainThread");
 449 #elif defined(HAVE_PTHREAD_SETNAME_NP_WITHOUT_TID)
 450     pthread_setname_np ("MainThread");
 451 #endif
 452 #endif
 453
 454 }
 455
 456 /**
 457  * Start the threaded generation of input events. This routine complements what
 458  * was previously done by InputThreadPreInit(), being only responsible for
 459  * creating the dedicated input thread.
 460  *
 461  */
 462 void
 463 InputThreadInit(void)
 464 {
 465     pthread_attr_t attr;
 466
 467     /* If the driver hasn't asked for input thread support by calling
 468      * InputThreadPreInit, then do nothing here
 469      */
 470     if (!inputThreadInfo)
 471         return;
 472
 473     pthread_attr_init(&attr);
 474
 475     /* For OSes that differentiate between processes and threads, the following
 476      * lines have sense. Linux uses the 1:1 thread model. The scheduler handles
 477      * every thread as a normal process. Therefore this probably has no meaning
 478      * if we are under Linux.
 479      */
 480     if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0)
 481         ErrorF("input-thread: error setting thread scope\n");
 482
 483     DebugF("input-thread: creating thread\n");
 484     pthread_create(&inputThreadInfo->thread, &attr,
 485                    &InputThreadDoWork, NULL);
 486
 487     pthread_attr_destroy (&attr);
 488 }
 489
 490 /**
 491  * Stop the threaded generation of input events
 492  *
 493  * This function is supposed to be called at server shutdown time only.
 494  */
 495 void
 496 InputThreadFini(void)
 497 {
 498     InputThreadDevice *dev, *next;
 499
 500     if (!inputThreadInfo)
 501         return;
 502
 503     /* Close the pipe to get the input thread to shut down */
 504     close(hotplugPipeWrite);
 505     input_force_unlock();
 506     pthread_join(inputThreadInfo->thread, NULL);
 507
 508     xorg_list_for_each_entry_safe(dev, next, &inputThreadInfo->devs, node) {
 509         ospoll_remove(inputThreadInfo->fds, dev->fd);
 510         free(dev);
 511     }
 512     xorg_list_init(&inputThreadInfo->devs);
 513     ospoll_destroy(inputThreadInfo->fds);
 514
 515     RemoveNotifyFd(inputThreadInfo->readPipe);
 516     close(inputThreadInfo->readPipe);
 517     close(inputThreadInfo->writePipe);
 518     inputThreadInfo->readPipe = -1;
 519     inputThreadInfo->writePipe = -1;
 520
 521     close(hotplugPipeRead);
 522     hotplugPipeRead = -1;
 523     hotplugPipeWrite = -1;
 524
 525     free(inputThreadInfo);
 526     inputThreadInfo = NULL;
 527 }
 528
 529 int xthread_sigmask(int how, const sigset_t *set, sigset_t *oldset)
 530 {
 531     return pthread_sigmask(how, set, oldset);
 532 }
 533
 534 #else /* INPUTTHREAD */
 535
 536 Bool InputThreadEnable = FALSE;
 537
 538 void input_lock(void) {}
 539 void input_unlock(void) {}
 540 void input_force_unlock(void) {}
 541
 542 void InputThreadPreInit(void) {}
 543 void InputThreadInit(void) {}
 544 void InputThreadFini(void) {}
 545 int in_input_thread(void) { return 0; }
 546
 547 int InputThreadRegisterDev(int fd,
 548                            NotifyFdProcPtr readInputProc,
 549                            void *readInputArgs)
 550 {
 551     return SetNotifyFd(fd, readInputProc, X_NOTIFY_READ, readInputArgs);
 552 }
 553
 554 extern int InputThreadUnregisterDev(int fd)
 555 {
 556     RemoveNotifyFd(fd);
 557     return 1;
 558 }
 559
 560 int xthread_sigmask(int how, const sigset_t *set, sigset_t *oldset)
 561 {
 562 #ifdef HAVE_SIGPROCMASK
 563     return sigprocmask(how, set, oldset);
 564 #else
 565     return 0;
 566 #endif
 567 }
 568
 569 #endif