xorg-server-1.4/os/WaitFor.c

   1 /***********************************************************
   2
   3 Copyright 1987, 1998  The Open Group
   4
   5 Permission to use, copy, modify, distribute, and sell this software and its
   6 documentation for any purpose is hereby granted without fee, provided that
   7 the above copyright notice appear in all copies and that both that
   8 copyright notice and this permission notice appear in supporting
   9 documentation.
  10
  11 The above copyright notice and this permission notice shall be included in
  12 all copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  17 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  18 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  19 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  20
  21 Except as contained in this notice, the name of The Open Group shall not be
  22 used in advertising or otherwise to promote the sale, use or other dealings
  23 in this Software without prior written authorization from The Open Group.
  24
  25
  26 Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
  27
  28                         All Rights Reserved
  29
  30 Permission to use, copy, modify, and distribute this software and its
  31 documentation for any purpose and without fee is hereby granted,
  32 provided that the above copyright notice appear in all copies and that
  33 both that copyright notice and this permission notice appear in
  34 supporting documentation, and that the name of Digital not be
  35 used in advertising or publicity pertaining to distribution of the
  36 software without specific, written prior permission.
  37
  38 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  39 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  40 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  41 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  42 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  43 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  44 SOFTWARE.
  45
  46 ******************************************************************/
  47
  48
  49 /*****************************************************************
  50  * OS Dependent input routines:
  51  *
  52  *  WaitForSomething
  53  *  TimerForce, TimerSet, TimerCheck, TimerFree
  54  *
  55  *****************************************************************/
  56
  57 #ifdef HAVE_DIX_CONFIG_H
  58 #include <dix-config.h>
  59 #endif
  60
  61 #ifdef WIN32
  62 #include <X11/Xwinsock.h>
  63 #endif
  64 #include <X11/Xos.h>                    /* for strings, fcntl, time */
  65 #include <errno.h>
  66 #include <stdio.h>
  67 #include <X11/X.h>
  68 #include "misc.h"
  69
  70 #include "osdep.h"
  71 #include <X11/Xpoll.h>
  72 #include "dixstruct.h"
  73 #include "opaque.h"
  74 #ifdef DPMSExtension
  75 #include "dpmsproc.h"
  76 #endif
  77
  78 #ifdef WIN32
  79 /* Error codes from windows sockets differ from fileio error codes  */
  80 #undef EINTR
  81 #define EINTR WSAEINTR
  82 #undef EINVAL
  83 #define EINVAL WSAEINVAL
  84 #undef EBADF
  85 #define EBADF WSAENOTSOCK
  86 /* Windows select does not set errno. Use GetErrno as wrapper for
  87    WSAGetLastError */
  88 #define GetErrno WSAGetLastError
  89 #else
  90 /* This is just a fallback to errno to hide the differences between unix and
  91    Windows in the code */
  92 #define GetErrno() errno
  93 #endif
  94
  95 /* modifications by raphael */
  96 int
  97 mffs(fd_mask mask)
  98 {
  99     int i;
 100
 101     if (!mask) return 0;
 102     i = 1;
 103     while (!(mask & 1))
 104     {
 105         i++;
 106         mask >>= 1;
 107     }
 108     return i;
 109 }
 110
 111 #ifdef DPMSExtension
 112 #define DPMS_SERVER
 113 #include <X11/extensions/dpms.h>
 114 #endif
 115
 116 struct _OsTimerRec {
 117     OsTimerPtr          next;
 118     CARD32              expires;
 119     CARD32              delta;
 120     OsTimerCallback     callback;
 121     pointer             arg;
 122 };
 123
 124 static void DoTimer(OsTimerPtr timer, CARD32 now, OsTimerPtr *prev);
 125 static void CheckAllTimers(void);
 126 static OsTimerPtr timers = NULL;
 127
 128 /*****************
 129  * WaitForSomething:
 130  *     Make the server suspend until there is
 131  *      1. data from clients or
 132  *      2. input events available or
 133  *      3. ddx notices something of interest (graphics
 134  *         queue ready, etc.) or
 135  *      4. clients that have buffered replies/events are ready
 136  *
 137  *     If the time between INPUT events is
 138  *     greater than ScreenSaverTime, the display is turned off (or
 139  *     saved, depending on the hardware).  So, WaitForSomething()
 140  *     has to handle this also (that's why the select() has a timeout.
 141  *     For more info on ClientsWithInput, see ReadRequestFromClient().
 142  *     pClientsReady is an array to store ready client->index values into.
 143  *****************/
 144
 145 int
 146 WaitForSomething(int *pClientsReady)
 147 {
 148     int i;
 149     struct timeval waittime, *wt;
 150     INT32 timeout = 0;
 151     fd_set clientsReadable;
 152     fd_set clientsWritable;
 153     int curclient;
 154     int selecterr;
 155     int nready;
 156     fd_set devicesReadable;
 157     CARD32 now = 0;
 158 #ifdef SMART_SCHEDULE
 159     Bool    someReady = FALSE;
 160 #endif
 161
 162     FD_ZERO(&clientsReadable);
 163
 164     /* We need a while loop here to handle
 165        crashed connections and the screen saver timeout */
 166     while (1)
 167     {
 168         /* deal with any blocked jobs */
 169         if (workQueue)
 170             ProcessWorkQueue();
 171         if (XFD_ANYSET (&ClientsWithInput))
 172         {
 173 #ifdef SMART_SCHEDULE
 174             if (!SmartScheduleDisable)
 175             {
 176                 someReady = TRUE;
 177                 waittime.tv_sec = 0;
 178                 waittime.tv_usec = 0;
 179                 wt = &waittime;
 180             }
 181             else
 182 #endif
 183             {
 184                 XFD_COPYSET (&ClientsWithInput, &clientsReadable);
 185                 break;
 186             }
 187         }
 188 #ifdef SMART_SCHEDULE
 189         if (someReady)
 190         {
 191             XFD_COPYSET(&AllSockets, &LastSelectMask);
 192             XFD_UNSET(&LastSelectMask, &ClientsWithInput);
 193         }
 194         else
 195         {
 196 #endif
 197         wt = NULL;
 198         if (timers)
 199         {
 200             now = GetTimeInMillis();
 201             timeout = timers->expires - now;
 202             if (timeout > 0 && timeout > timers->delta + 250) {
 203                 /* time has rewound.  reset the timers. */
 204                 CheckAllTimers();
 205             }
 206
 207             if (timers) {
 208                 timeout = timers->expires - now;
 209                 if (timeout < 0)
 210                     timeout = 0;
 211                 waittime.tv_sec = timeout / MILLI_PER_SECOND;
 212                 waittime.tv_usec = (timeout % MILLI_PER_SECOND) *
 213                                    (1000000 / MILLI_PER_SECOND);
 214                 wt = &waittime;
 215             }
 216         }
 217         XFD_COPYSET(&AllSockets, &LastSelectMask);
 218 #ifdef SMART_SCHEDULE
 219         }
 220         SmartScheduleIdle = TRUE;
 221 #endif
 222         BlockHandler((pointer)&wt, (pointer)&LastSelectMask);
 223         if (NewOutputPending)
 224             FlushAllOutput();
 225         /* keep this check close to select() call to minimize race */
 226         if (dispatchException)
 227             i = -1;
 228         else if (AnyClientsWriteBlocked)
 229         {
 230             XFD_COPYSET(&ClientsWriteBlocked, &clientsWritable);
 231             i = Select (MaxClients, &LastSelectMask, &clientsWritable, NULL, wt);
 232         }
 233         else
 234         {
 235             i = Select (MaxClients, &LastSelectMask, NULL, NULL, wt);
 236         }
 237         selecterr = GetErrno();
 238         WakeupHandler(i, (pointer)&LastSelectMask);
 239 #ifdef SMART_SCHEDULE
 240         if (i >= 0)
 241         {
 242             SmartScheduleIdle = FALSE;
 243             SmartScheduleIdleCount = 0;
 244             if (SmartScheduleTimerStopped)
 245                 (void) SmartScheduleStartTimer ();
 246         }
 247 #endif
 248         if (i <= 0) /* An error or timeout occurred */
 249         {
 250             if (dispatchException)
 251                 return 0;
 252             if (i < 0)
 253             {
 254                 if (selecterr == EBADF)    /* Some client disconnected */
 255                 {
 256                     CheckConnections ();
 257                     if (! XFD_ANYSET (&AllClients))
 258                         return 0;
 259                 }
 260                 else if (selecterr == EINVAL)
 261                 {
 262                     FatalError("WaitForSomething(): select: errno=%d\n",
 263                         selecterr);
 264             }
 265                 else if (selecterr != EINTR)
 266                 {
 267                     ErrorF("WaitForSomething(): select: errno=%d\n",
 268                         selecterr);
 269                 }
 270             }
 271 #ifdef SMART_SCHEDULE
 272             else if (someReady)
 273             {
 274                 /*
 275                  * If no-one else is home, bail quickly
 276                  */
 277                 XFD_COPYSET(&ClientsWithInput, &LastSelectMask);
 278                 XFD_COPYSET(&ClientsWithInput, &clientsReadable);
 279                 break;
 280             }
 281 #endif
 282             if (*checkForInput[0] != *checkForInput[1])
 283                 return 0;
 284
 285             if (timers)
 286             {
 287                 int expired = 0;
 288                 now = GetTimeInMillis();
 289                 if ((int) (timers->expires - now) <= 0)
 290                     expired = 1;
 291
 292                 while (timers && (int) (timers->expires - now) <= 0)
 293                     DoTimer(timers, now, &timers);
 294
 295                 if (expired)
 296                     return 0;
 297             }
 298         }
 299         else
 300         {
 301             fd_set tmp_set;
 302
 303             if (*checkForInput[0] == *checkForInput[1]) {
 304                 if (timers)
 305                 {
 306                     int expired = 0;
 307                     now = GetTimeInMillis();
 308                     if ((int) (timers->expires - now) <= 0)
 309                         expired = 1;
 310
 311                     while (timers && (int) (timers->expires - now) <= 0)
 312                         DoTimer(timers, now, &timers);
 313
 314                     if (expired)
 315                         return 0;
 316                 }
 317             }
 318 #ifdef SMART_SCHEDULE
 319             if (someReady)
 320                 XFD_ORSET(&LastSelectMask, &ClientsWithInput, &LastSelectMask);
 321 #endif
 322             if (AnyClientsWriteBlocked && XFD_ANYSET (&clientsWritable))
 323             {
 324                 NewOutputPending = TRUE;
 325                 XFD_ORSET(&OutputPending, &clientsWritable, &OutputPending);
 326                 XFD_UNSET(&ClientsWriteBlocked, &clientsWritable);
 327                 if (! XFD_ANYSET(&ClientsWriteBlocked))
 328                     AnyClientsWriteBlocked = FALSE;
 329             }
 330
 331             XFD_ANDSET(&devicesReadable, &LastSelectMask, &EnabledDevices);
 332             XFD_ANDSET(&clientsReadable, &LastSelectMask, &AllClients);
 333             XFD_ANDSET(&tmp_set, &LastSelectMask, &WellKnownConnections);
 334             if (XFD_ANYSET(&tmp_set))
 335                 QueueWorkProc(EstablishNewConnections, NULL,
 336                               (pointer)&LastSelectMask);
 337
 338             if (XFD_ANYSET (&devicesReadable) || XFD_ANYSET (&clientsReadable))
 339                 break;
 340 #ifdef WIN32
 341             /* Windows keyboard and mouse events are added to the input queue
 342                in Block- and WakupHandlers. There is no device to check if
 343                data is ready. So check here if new input is available */
 344             if (*checkForInput[0] != *checkForInput[1])
 345                 return 0;
 346 #endif
 347         }
 348     }
 349
 350     nready = 0;
 351     if (XFD_ANYSET (&clientsReadable))
 352     {
 353 #ifndef WIN32
 354         for (i=0; i<howmany(XFD_SETSIZE, NFDBITS); i++)
 355         {
 356             int highest_priority = 0;
 357
 358             while (clientsReadable.fds_bits[i])
 359             {
 360                 int client_priority, client_index;
 361
 362                 curclient = ffs (clientsReadable.fds_bits[i]) - 1;
 363                 client_index = /* raphael: modified */
 364                         ConnectionTranslation[curclient + (i * (sizeof(fd_mask) * 8))];
 365 #else
 366         int highest_priority = 0;
 367         fd_set savedClientsReadable;
 368         XFD_COPYSET(&clientsReadable, &savedClientsReadable);
 369         for (i = 0; i < XFD_SETCOUNT(&savedClientsReadable); i++)
 370         {
 371             int client_priority, client_index;
 372
 373             curclient = XFD_FD(&savedClientsReadable, i);
 374             client_index = GetConnectionTranslation(curclient);
 375 #endif
 376 #ifdef XSYNC
 377                 /*  We implement "strict" priorities.
 378                  *  Only the highest priority client is returned to
 379                  *  dix.  If multiple clients at the same priority are
 380                  *  ready, they are all returned.  This means that an
 381                  *  aggressive client could take over the server.
 382                  *  This was not considered a big problem because
 383                  *  aggressive clients can hose the server in so many
 384                  *  other ways :)
 385                  */
 386                 client_priority = clients[client_index]->priority;
 387                 if (nready == 0 || client_priority > highest_priority)
 388                 {
 389                     /*  Either we found the first client, or we found
 390                      *  a client whose priority is greater than all others
 391                      *  that have been found so far.  Either way, we want
 392                      *  to initialize the list of clients to contain just
 393                      *  this client.
 394                      */
 395                     pClientsReady[0] = client_index;
 396                     highest_priority = client_priority;
 397                     nready = 1;
 398                 }
 399                 /*  the following if makes sure that multiple same-priority
 400                  *  clients get batched together
 401                  */
 402                 else if (client_priority == highest_priority)
 403 #endif
 404                 {
 405                     pClientsReady[nready++] = client_index;
 406                 }
 407 #ifndef WIN32
 408                 clientsReadable.fds_bits[i] &= ~(((fd_mask)1L) << curclient);
 409             }
 410 #else
 411             FD_CLR(curclient, &clientsReadable);
 412 #endif
 413         }
 414     }
 415     return nready;
 416 }
 417
 418 #if 0
 419 /*
 420  * This is not always a macro.
 421  */
 422 ANYSET(FdMask *src)
 423 {
 424     int i;
 425
 426     for (i=0; i<mskcnt; i++)
 427         if (src[ i ])
 428             return (TRUE);
 429     return (FALSE);
 430 }
 431 #endif
 432
 433 /* If time has rewound, re-run every affected timer.
 434  * Timers might drop out of the list, so we have to restart every time. */
 435 static void
 436 CheckAllTimers(void)
 437 {
 438     OsTimerPtr timer;
 439     CARD32 now;
 440
 441 start:
 442     now = GetTimeInMillis();
 443
 444     for (timer = timers; timer; timer = timer->next) {
 445         if (timer->expires - now > timer->delta + 250) {
 446             TimerForce(timer);
 447             goto start;
 448         }
 449     }
 450 }
 451
 452 static void
 453 DoTimer(OsTimerPtr timer, CARD32 now, OsTimerPtr *prev)
 454 {
 455     CARD32 newTime;
 456
 457     *prev = timer->next;
 458     timer->next = NULL;
 459     newTime = (*timer->callback)(timer, now, timer->arg);
 460     if (newTime)
 461         TimerSet(timer, 0, newTime, timer->callback, timer->arg);
 462 }
 463
 464 _X_EXPORT OsTimerPtr
 465 TimerSet(OsTimerPtr timer, int flags, CARD32 millis,
 466     OsTimerCallback func, pointer arg)
 467 {
 468     register OsTimerPtr *prev;
 469     CARD32 now = GetTimeInMillis();
 470
 471     if (!timer)
 472     {
 473         timer = (OsTimerPtr)xalloc(sizeof(struct _OsTimerRec));
 474         if (!timer)
 475             return NULL;
 476     }
 477     else
 478     {
 479         for (prev = &timers; *prev; prev = &(*prev)->next)
 480         {
 481             if (*prev == timer)
 482             {
 483                 *prev = timer->next;
 484                 if (flags & TimerForceOld)
 485                     (void)(*timer->callback)(timer, now, timer->arg);
 486                 break;
 487             }
 488         }
 489     }
 490     if (!millis)
 491         return timer;
 492     if (flags & TimerAbsolute) {
 493         timer->delta = millis - now;
 494     }
 495     else {
 496         timer->delta = millis;
 497         millis += now;
 498     }
 499     timer->expires = millis;
 500     timer->callback = func;
 501     timer->arg = arg;
 502     if ((int) (millis - now) <= 0)
 503     {
 504         timer->next = NULL;
 505         millis = (*timer->callback)(timer, now, timer->arg);
 506         if (!millis)
 507             return timer;
 508     }
 509     for (prev = &timers;
 510          *prev && (int) ((*prev)->expires - millis) <= 0;
 511          prev = &(*prev)->next)
 512         ;
 513     timer->next = *prev;
 514     *prev = timer;
 515     return timer;
 516 }
 517
 518 Bool
 519 TimerForce(OsTimerPtr timer)
 520 {
 521     OsTimerPtr *prev;
 522
 523     for (prev = &timers; *prev; prev = &(*prev)->next)
 524     {
 525         if (*prev == timer)
 526         {
 527             DoTimer(timer, GetTimeInMillis(), prev);
 528             return TRUE;
 529         }
 530     }
 531     return FALSE;
 532 }
 533
 534
 535 _X_EXPORT void
 536 TimerCancel(OsTimerPtr timer)
 537 {
 538     OsTimerPtr *prev;
 539
 540     if (!timer)
 541         return;
 542     for (prev = &timers; *prev; prev = &(*prev)->next)
 543     {
 544         if (*prev == timer)
 545         {
 546             *prev = timer->next;
 547             break;
 548         }
 549     }
 550 }
 551
 552 _X_EXPORT void
 553 TimerFree(OsTimerPtr timer)
 554 {
 555     if (!timer)
 556         return;
 557     TimerCancel(timer);
 558     xfree(timer);
 559 }
 560
 561 void
 562 TimerCheck(void)
 563 {
 564     CARD32 now = GetTimeInMillis();
 565
 566     while (timers && (int) (timers->expires - now) <= 0)
 567         DoTimer(timers, now, &timers);
 568 }
 569
 570 void
 571 TimerInit(void)
 572 {
 573     OsTimerPtr timer;
 574
 575     while ((timer = timers))
 576     {
 577         timers = timer->next;
 578         xfree(timer);
 579     }
 580 }
 581
 582 #ifdef DPMSExtension
 583
 584 #define DPMS_CHECK_MODE(mode,time)\
 585     if (time > 0 && DPMSPowerLevel < mode && timeout >= time)\
 586         DPMSSet(mode);
 587
 588 #define DPMS_CHECK_TIMEOUT(time)\
 589     if (time > 0 && (time - timeout) > 0)\
 590         return time - timeout;
 591
 592 static CARD32
 593 NextDPMSTimeout(INT32 timeout)
 594 {
 595     /*
 596      * Return the amount of time remaining until we should set
 597      * the next power level. Fallthroughs are intentional.
 598      */
 599     switch (DPMSPowerLevel)
 600     {
 601         case DPMSModeOn:
 602             DPMS_CHECK_TIMEOUT(DPMSStandbyTime)
 603
 604         case DPMSModeStandby:
 605             DPMS_CHECK_TIMEOUT(DPMSSuspendTime)
 606
 607         case DPMSModeSuspend:
 608             DPMS_CHECK_TIMEOUT(DPMSOffTime)
 609
 610         default: /* DPMSModeOff */
 611             return 0;
 612     }
 613 }
 614 #endif /* DPMSExtension */
 615
 616 static CARD32
 617 ScreenSaverTimeoutExpire(OsTimerPtr timer,CARD32 now,pointer arg)
 618 {
 619     INT32 timeout      = now - lastDeviceEventTime.milliseconds;
 620     CARD32 nextTimeout = 0;
 621
 622 #ifdef DPMSExtension
 623     /*
 624      * Check each mode lowest to highest, since a lower mode can
 625      * have the same timeout as a higher one.
 626      */
 627     if (DPMSEnabled)
 628     {
 629         DPMS_CHECK_MODE(DPMSModeOff,     DPMSOffTime)
 630         DPMS_CHECK_MODE(DPMSModeSuspend, DPMSSuspendTime)
 631         DPMS_CHECK_MODE(DPMSModeStandby, DPMSStandbyTime)
 632
 633         nextTimeout = NextDPMSTimeout(timeout);
 634     }
 635
 636     /*
 637      * Only do the screensaver checks if we're not in a DPMS
 638      * power saving mode
 639      */
 640     if (DPMSPowerLevel != DPMSModeOn)
 641         return nextTimeout;
 642 #endif /* DPMSExtension */
 643
 644     if (!ScreenSaverTime)
 645         return nextTimeout;
 646
 647     if (timeout < ScreenSaverTime)
 648     {
 649         return nextTimeout > 0 ?
 650                 min(ScreenSaverTime - timeout, nextTimeout) :
 651                 ScreenSaverTime - timeout;
 652     }
 653
 654     ResetOsBuffers(); /* not ideal, but better than nothing */
 655     SaveScreens(SCREEN_SAVER_ON, ScreenSaverActive);
 656
 657     if (ScreenSaverInterval > 0)
 658     {
 659         nextTimeout = nextTimeout > 0 ?
 660                 min(ScreenSaverInterval, nextTimeout) :
 661                 ScreenSaverInterval;
 662     }
 663
 664     return nextTimeout;
 665 }
 666
 667 static OsTimerPtr ScreenSaverTimer = NULL;
 668
 669 void
 670 FreeScreenSaverTimer(void)
 671 {
 672     if (ScreenSaverTimer) {
 673         TimerFree(ScreenSaverTimer);
 674         ScreenSaverTimer = NULL;
 675     }
 676 }
 677
 678 void
 679 SetScreenSaverTimer(void)
 680 {
 681     CARD32 timeout = 0;
 682
 683 #ifdef DPMSExtension
 684     if (DPMSEnabled)
 685     {
 686         /*
 687          * A higher DPMS level has a timeout that's either less
 688          * than or equal to that of a lower DPMS level.
 689          */
 690         if (DPMSStandbyTime > 0)
 691             timeout = DPMSStandbyTime;
 692
 693         else if (DPMSSuspendTime > 0)
 694             timeout = DPMSSuspendTime;
 695
 696         else if (DPMSOffTime > 0)
 697             timeout = DPMSOffTime;
 698     }
 699 #endif
 700
 701     if (ScreenSaverTime > 0)
 702     {
 703         timeout = timeout > 0 ?
 704                 min(ScreenSaverTime, timeout) :
 705                 ScreenSaverTime;
 706     }
 707
 708 #ifdef SCREENSAVER
 709     if (timeout && !screenSaverSuspended) {
 710 #else
 711     if (timeout) {
 712 #endif
 713         ScreenSaverTimer = TimerSet(ScreenSaverTimer, 0, timeout,
 714                                     ScreenSaverTimeoutExpire, NULL);
 715     }
 716     else if (ScreenSaverTimer) {
 717         FreeScreenSaverTimer();
 718     }
 719 }
 720