exp_poll.c

   1 /* exp_poll.c - This file contains UNIX specific procedures for
   2  * poll-based notifier, which is the lowest-level part of the Tcl
   3  * event loop.  This file works together with ../generic/tclNotify.c.
   4  *
   5  * Design and implementation of this program was paid for by U.S. tax
   6  * dollars.  Therefore it is public domain.  However, the author and
   7  * NIST would appreciate credit if this program or parts of it are
   8  * used.
   9  *
  10  * Written by Don Libes, NIST, 2/6/90
  11  * Rewritten by Don Libes, 2/96 for new Tcl notifier paradigm.
  12  * Rewritten again by Don Libes, 8/97 for yet another Tcl notifier paradigm.
  13  */
  14
  15 #include "tclInt.h"
  16 #include "tclPort.h"
  17 #include <signal.h>
  18
  19 #include <poll.h>
  20 #include <sys/types.h>
  21
  22 #ifdef HAVE_UNISTD_H
  23 #  include <unistd.h>
  24 #endif
  25
  26 /* Some systems require that the poll array be non-empty so provide a
  27  * 1-elt array for starters.  It will be ignored as soon as it grows
  28  * larger.
  29  */
  30
  31 static struct pollfd initialFdArray;
  32 static struct pollfd *fdArray = &initialFdArray;
  33 static int fdsInUse = 0;        /* space in use */
  34 static int fdsMaxSpace = 1;     /* space that has actually been allocated */
  35
  36 /*
  37  * tclUnixNotify.c --
  38  *
  39  *      This file contains the implementation of the select-based
  40  *      Unix-specific notifier, which is the lowest-level part of the
  41  *      Tcl event loop.  This file works together with
  42  *      ../generic/tclNotify.c.
  43  *
  44  * Copyright (c) 1995-1997 Sun Microsystems, Inc.
  45  *
  46  * See the file "license.terms" for information on usage and redistribution
  47  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  48  *
  49  * SCCS: @(#) tclUnixNotfy.c 1.42 97/07/02 20:55:44
  50  */
  51
  52 /*
  53  * This structure is used to keep track of the notifier info for a
  54  * a registered file.
  55  */
  56
  57 typedef struct FileHandler {
  58     int fd;
  59     int mask;                   /* Mask of desired events: TCL_READABLE,
  60                                  * etc. */
  61     int readyMask;              /* Mask of events that have been seen since the
  62                                  * last time file handlers were invoked for
  63                                  * this file. */
  64     Tcl_FileProc *proc;         /* Procedure to call, in the style of
  65                                  * Tcl_CreateFileHandler. */
  66     ClientData clientData;      /* Argument to pass to proc. */
  67     int pollArrayIndex;         /* index into poll array */
  68     struct FileHandler *nextPtr;/* Next in list of all files we care about. */
  69 } FileHandler;
  70
  71 /*
  72  * The following structure is what is added to the Tcl event queue when
  73  * file handlers are ready to fire.
  74  */
  75
  76 typedef struct FileHandlerEvent {
  77     Tcl_Event header;           /* Information that is standard for
  78                                  * all events. */
  79     int fd;                     /* File descriptor that is ready.  Used
  80                                  * to find the FileHandler structure for
  81                                  * the file (can't point directly to the
  82                                  * FileHandler structure because it could
  83                                  * go away while the event is queued). */
  84 } FileHandlerEvent;
  85
  86 /*
  87  * The following static structure contains the state information for the
  88  * select based implementation of the Tcl notifier.
  89  */
  90
  91 static struct {
  92     FileHandler *firstFileHandlerPtr;
  93                                 /* Pointer to head of file handler list. */
  94     fd_mask checkMasks[3*MASK_SIZE];
  95                                 /* This array is used to build up the masks
  96                                  * to be used in the next call to select.
  97                                  * Bits are set in response to calls to
  98                                  * Tcl_CreateFileHandler. */
  99     fd_mask readyMasks[3*MASK_SIZE];
 100                                 /* This array reflects the readable/writable
 101                                  * conditions that were found to exist by the
 102                                  * last call to select. */
 103     int numFdBits;              /* Number of valid bits in checkMasks
 104                                  * (one more than highest fd for which
 105                                  * Tcl_WatchFile has been called). */
 106 } notifier;
 107
 108 /*
 109  * The following static indicates whether this module has been initialized.
 110  */
 111
 112 static int initialized = 0;
 113
 114 /*
 115  * Static routines defined in this file.
 116  */
 117
 118 static void             InitNotifier _ANSI_ARGS_((void));
 119 static void             NotifierExitHandler _ANSI_ARGS_((
 120                             ClientData clientData));
 121 static int              FileHandlerEventProc _ANSI_ARGS_((Tcl_Event *evPtr,
 122                             int flags));
 123 \f
 124 /*
 125  *----------------------------------------------------------------------
 126  *
 127  * InitNotifier --
 128  *
 129  *      Initializes the notifier state.
 130  *
 131  * Results:
 132  *      None.
 133  *
 134  * Side effects:
 135  *      Creates a new exit handler.
 136  *
 137  *----------------------------------------------------------------------
 138  */
 139
 140 static void
 141 InitNotifier()
 142 {
 143     initialized = 1;
 144     memset(&notifier, 0, sizeof(notifier));
 145     Tcl_CreateExitHandler(NotifierExitHandler, NULL);
 146 }
 147 \f
 148 /*
 149  *----------------------------------------------------------------------
 150  *
 151  * NotifierExitHandler --
 152  *
 153  *      This function is called to cleanup the notifier state before
 154  *      Tcl is unloaded.
 155  *
 156  * Results:
 157  *      None.
 158  *
 159  * Side effects:
 160  *      Destroys the notifier window.
 161  *
 162  *----------------------------------------------------------------------
 163  */
 164
 165 static void
 166 NotifierExitHandler(clientData)
 167     ClientData clientData;              /* Not used. */
 168 {
 169     initialized = 0;
 170 }
 171 \f
 172 /*
 173  *----------------------------------------------------------------------
 174  *
 175  * Tcl_SetTimer --
 176  *
 177  *      This procedure sets the current notifier timer value.  This
 178  *      interface is not implemented in this notifier because we are
 179  *      always running inside of Tcl_DoOneEvent.
 180  *
 181  * Results:
 182  *      None.
 183  *
 184  * Side effects:
 185  *      None.
 186  *
 187  *----------------------------------------------------------------------
 188  */
 189
 190 void
 191 Tcl_SetTimer(timePtr)
 192     Tcl_Time *timePtr;          /* Timeout value, may be NULL. */
 193 {
 194     /*
 195      * The interval timer doesn't do anything in this implementation,
 196      * because the only event loop is via Tcl_DoOneEvent, which passes
 197      * timeout values to Tcl_WaitForEvent.
 198      */
 199 }
 200 \f
 201 /*
 202  *----------------------------------------------------------------------
 203  *
 204  * Tcl_CreateFileHandler --
 205  *
 206  *      This procedure registers a file handler with the Xt notifier.
 207  *
 208  * Results:
 209  *      None.
 210  *
 211  * Side effects:
 212  *      Creates a new file handler structure and registers one or more
 213  *      input procedures with Xt.
 214  *
 215  *----------------------------------------------------------------------
 216  */
 217
 218 void
 219 Tcl_CreateFileHandler(fd, mask, proc, clientData)
 220     int fd;                     /* Handle of stream to watch. */
 221     int mask;                   /* OR'ed combination of TCL_READABLE,
 222                                  * TCL_WRITABLE, and TCL_EXCEPTION:
 223                                  * indicates conditions under which
 224                                  * proc should be called. */
 225     Tcl_FileProc *proc;         /* Procedure to call for each
 226                                  * selected event. */
 227     ClientData clientData;      /* Arbitrary data to pass to proc. */
 228 {
 229     FileHandler *filePtr;
 230     int index, bit;
 231     int cur_fd_index;
 232
 233     if (!initialized) {
 234         InitNotifier();
 235     }
 236
 237     for (filePtr = notifier.firstFileHandlerPtr; filePtr != NULL;
 238             filePtr = filePtr->nextPtr) {
 239         if (filePtr->fd == fd) {
 240             break;
 241         }
 242     }
 243     if (filePtr == NULL) {
 244         filePtr = (FileHandler*) ckalloc(sizeof(FileHandler)); /* MLK */
 245         filePtr->fd = fd;
 246         filePtr->readyMask = 0;
 247         filePtr->nextPtr = notifier.firstFileHandlerPtr;
 248         notifier.firstFileHandlerPtr = filePtr;
 249     }
 250     filePtr->proc = proc;
 251     filePtr->clientData = clientData;
 252     filePtr->pollArrayIndex = fdsInUse;
 253     cur_fd_index = fdsInUse;
 254
 255     fdsInUse++;
 256     if (fdsInUse > fdsMaxSpace) {
 257         if (fdArray != &initialFdArray) ckfree((char *)fdArray);
 258         fdArray = (struct pollfd *)ckalloc(fdsInUse*sizeof(struct pollfd));
 259         fdsMaxSpace = fdsInUse;
 260     }
 261
 262     fdArray[cur_fd_index].fd = fd;
 263
 264     /* I know that POLLIN/OUT is right.  But I have no idea if POLLPRI
 265      * corresponds well to TCL_EXCEPTION.
 266      */
 267
 268     if (mask & TCL_READABLE) {
 269         fdArray[cur_fd_index].events = POLLIN;
 270     }
 271     if (mask & TCL_WRITABLE) {
 272         fdArray[cur_fd_index].events = POLLOUT;
 273     }
 274     if (mask & TCL_EXCEPTION) {
 275         fdArray[cur_fd_index].events = POLLPRI;
 276     }
 277 }
 278 \f
 279 /*
 280  *----------------------------------------------------------------------
 281  *
 282  * Tcl_DeleteFileHandler --
 283  *
 284  *      Cancel a previously-arranged callback arrangement for
 285  *      a file.
 286  *
 287  * Results:
 288  *      None.
 289  *
 290  * Side effects:
 291  *      If a callback was previously registered on file, remove it.
 292  *
 293  *----------------------------------------------------------------------
 294  */
 295
 296 void
 297 Tcl_DeleteFileHandler(fd)
 298     int fd;             /* Stream id for which to remove callback procedure. */
 299 {
 300     FileHandler *filePtr, *prevPtr, *lastPtr;
 301     int index, bit, mask, i;
 302     int cur_fd_index;
 303
 304     if (!initialized) {
 305         InitNotifier();
 306     }
 307
 308     /*
 309      * Find the entry for the given file (and return if there
 310      * isn't one).
 311      */
 312
 313     for (prevPtr = NULL, filePtr = notifier.firstFileHandlerPtr; ;
 314             prevPtr = filePtr, filePtr = filePtr->nextPtr) {
 315         if (filePtr == NULL) {
 316             return;
 317         }
 318         if (filePtr->fd == fd) {
 319             break;
 320         }
 321     }
 322
 323     /*
 324      * Clean up information in the callback record.
 325      */
 326
 327     if (prevPtr == NULL) {
 328         notifier.firstFileHandlerPtr = filePtr->nextPtr;
 329     } else {
 330         prevPtr->nextPtr = filePtr->nextPtr;
 331     }
 332
 333     /* back to poll-specific code - DEL */
 334
 335     cur_fd_index = filePtr->pollArrayIndex;
 336     fdsInUse--;
 337
 338     /* if this one is last, do nothing special */
 339     /* else swap with one at end of array */
 340
 341     if (cur_fd_index != fdsInUse) {
 342         int lastfd_in_array = fdArray[fdsInUse].fd;
 343         memcpy(&fdArray[cur_fd_index],&fdArray[fdsInUse],sizeof(struct pollfd));
 344
 345         /* update index to reflect new location in array */
 346         /* first find link corresponding to last element in array */
 347
 348         for (lastPtr = notifier.firstFileHandlerPtr; filePtr; lastPtr = lastPtr->nextPtr) {
 349             if (lastPtr->fd == lastfd_in_array) {
 350                 lastPtr->pollArrayIndex = cur_fd_index;
 351                 break;
 352             }
 353         }
 354     }
 355
 356     fdsInUse--;
 357
 358     ckfree((char *) filePtr);
 359 }
 360 \f
 361 /*
 362  *----------------------------------------------------------------------
 363  *
 364  * FileHandlerEventProc --
 365  *
 366  *      This procedure is called by Tcl_ServiceEvent when a file event
 367  *      reaches the front of the event queue.  This procedure is
 368  *      responsible for actually handling the event by invoking the
 369  *      callback for the file handler.
 370  *
 371  * Results:
 372  *      Returns 1 if the event was handled, meaning it should be removed
 373  *      from the queue.  Returns 0 if the event was not handled, meaning
 374  *      it should stay on the queue.  The only time the event isn't
 375  *      handled is if the TCL_FILE_EVENTS flag bit isn't set.
 376  *
 377  * Side effects:
 378  *      Whatever the file handler's callback procedure does.
 379  *
 380  *----------------------------------------------------------------------
 381  */
 382
 383 static int
 384 FileHandlerEventProc(evPtr, flags)
 385     Tcl_Event *evPtr;           /* Event to service. */
 386     int flags;                  /* Flags that indicate what events to
 387                                  * handle, such as TCL_FILE_EVENTS. */
 388 {
 389     FileHandler *filePtr;
 390     FileHandlerEvent *fileEvPtr = (FileHandlerEvent *) evPtr;
 391     int mask;
 392
 393     if (!(flags & TCL_FILE_EVENTS)) {
 394         return 0;
 395     }
 396
 397     /*
 398      * Search through the file handlers to find the one whose handle matches
 399      * the event.  We do this rather than keeping a pointer to the file
 400      * handler directly in the event, so that the handler can be deleted
 401      * while the event is queued without leaving a dangling pointer.
 402      */
 403
 404     for (filePtr = notifier.firstFileHandlerPtr; filePtr != NULL;
 405             filePtr = filePtr->nextPtr) {
 406         if (filePtr->fd != fileEvPtr->fd) {
 407             continue;
 408         }
 409
 410         /*
 411          * The code is tricky for two reasons:
 412          * 1. The file handler's desired events could have changed
 413          *    since the time when the event was queued, so AND the
 414          *    ready mask with the desired mask.
 415          * 2. The file could have been closed and re-opened since
 416          *    the time when the event was queued.  This is why the
 417          *    ready mask is stored in the file handler rather than
 418          *    the queued event:  it will be zeroed when a new
 419          *    file handler is created for the newly opened file.
 420          */
 421
 422         mask = filePtr->readyMask & filePtr->mask;
 423         filePtr->readyMask = 0;
 424         if (mask != 0) {
 425             (*filePtr->proc)(filePtr->clientData, mask);
 426         }
 427         break;
 428     }
 429     return 1;
 430 }
 431 \f
 432 /*
 433  *----------------------------------------------------------------------
 434  *
 435  * Tcl_WaitForEvent --
 436  *
 437  *      This function is called by Tcl_DoOneEvent to wait for new
 438  *      events on the message queue.  If the block time is 0, then
 439  *      Tcl_WaitForEvent just polls without blocking.
 440  *
 441  * Results:
 442  *      Returns -1 if the select would block forever, otherwise
 443  *      returns 0.
 444  *
 445  * Side effects:
 446  *      Queues file events that are detected by the select.
 447  *
 448  *----------------------------------------------------------------------
 449  */
 450
 451 int
 452 Tcl_WaitForEvent(timePtr)
 453     Tcl_Time *timePtr;          /* Maximum block time, or NULL. */
 454 {
 455     FileHandler *filePtr;
 456     FileHandlerEvent *fileEvPtr;
 457     int timeout;
 458     struct timeval *timeoutPtr;
 459
 460     int bit, index, mask, numFound;
 461
 462     if (!initialized) {
 463         InitNotifier();
 464     }
 465
 466     /*
 467      * Set up the timeout structure.  Note that if there are no events to
 468      * check for, we return with a negative result rather than blocking
 469      * forever.
 470      */
 471
 472     if (timePtr) {
 473         timeout = timePtr->sec*1000 + timePtr->usec/1000;
 474
 475     } else if (notifier.numFdBits == 0) {
 476         return -1;
 477     } else {
 478         timeoutPtr = NULL;
 479     }
 480
 481     numFound = poll(fdArray,fdsInUse,timeout);
 482
 483     /*
 484      * Queue all detected file events before returning.
 485      */
 486
 487     for (filePtr = notifier.firstFileHandlerPtr;
 488             (filePtr != NULL) && (numFound > 0);
 489             filePtr = filePtr->nextPtr) {
 490         index = filePtr->pollArrayIndex;
 491         mask = 0;
 492
 493         if (fdArray[index].revents & POLLIN) {
 494             mask |= TCL_READABLE;
 495         }
 496         if (fdArray[index].revents & POLLOUT) {
 497             mask |= TCL_WRITABLE;
 498         }
 499         /* I have no idea if this is right ... */
 500         if (fdArray[index].revents & (POLLPRI|POLLERR|POLLHUP|POLLNVAL)) {
 501             mask |= TCL_EXCEPTION;
 502         }
 503
 504         if (!mask) {
 505             continue;
 506         } else {
 507             numFound--;
 508         }
 509
 510         /*
 511          * Don't bother to queue an event if the mask was previously
 512          * non-zero since an event must still be on the queue.
 513          */
 514
 515         if (filePtr->readyMask == 0) {
 516             fileEvPtr = (FileHandlerEvent *) ckalloc(
 517                 sizeof(FileHandlerEvent));
 518             fileEvPtr->header.proc = FileHandlerEventProc;
 519             fileEvPtr->fd = filePtr->fd;
 520             Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
 521         }
 522         filePtr->readyMask = mask;
 523     }
 524     return 0;
 525 }
 526