src/lwp/iomgr.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*******************************************************************\
  11 *                                                                   *
  12 *       Information Technology Center                               *
  13 *       Carnegie-Mellon University                                  *
  14 *                                                                   *
  15 *                                                                   *
  16 *                                                                   *
  17 \*******************************************************************/
  18
  19
  20 /*
  21         IO Manager routines & server process for VICE server.
  22 */
  23
  24 /* This controls the size of an fd_set; it must be defined early before
  25  * the system headers define that type and the macros that operate on it.
  26  * Its value should be as large as the maximum file descriptor limit we
  27  * are likely to run into on any platform.  Right now, that is 65536
  28  * which is the default hard fd limit on Solaris 9 */
  29 /* We don't do this on Windows because on that platform there is code
  30  * which allocates fd_set's on the stack (IOMGR_Sleep on Win9x, and
  31  * FDSetAnd on WinNT) */
  32 #ifndef _WIN32
  33 #define FD_SETSIZE 65536
  34 #endif
  35
  36 #include <afsconfig.h>
  37 #include <afs/param.h>
  38
  39 #include <roken.h>
  40
  41 #ifdef HAVE_SYS_SELECT_H
  42 #include <sys/select.h>
  43 #endif
  44
  45 #include <afs/opr.h>
  46
  47 #include "lwp.h"
  48 #include "timer.h"
  49
  50 typedef unsigned char bool;
  51 #define FALSE   0
  52 #define TRUE    1
  53
  54 #ifndef MIN
  55 #define MIN(a,b) (((a)>(b)) ? (b) : (a))
  56 #endif
  57
  58 #ifndef NSIG
  59 #define NSIG 8*sizeof(sigset_t)
  60 #endif
  61
  62 static int SignalSignals(void);
  63
  64 /********************************\
  65 *                                *
  66 *  Stuff for managing IoRequests *
  67 *                                *
  68 \********************************/
  69
  70 struct IoRequest {
  71
  72     /* Pid of process making request (for use in IOMGR_Cancel */
  73     PROCESS             pid;
  74
  75     /* Descriptor masks for requests */
  76     int                 nfds;
  77     fd_set              *readfds;
  78     fd_set              *writefds;
  79     fd_set              *exceptfds;
  80
  81     struct TM_Elem      timeout;
  82
  83     /* Result of select call */
  84     int                 result;
  85
  86     struct IoRequest    *next;  /* for iorFreeList */
  87
  88 };
  89
  90 /********************************\
  91 *                                *
  92 *  Stuff for managing signals    *
  93 *                                *
  94 \********************************/
  95
  96 #define badsig(signo)           (((signo) <= 0) || ((signo) >= NSIG))
  97 #define mysigmask(signo)                (1 << ((signo)-1))
  98
  99
 100 fd_set openMask;                /* mask of open files on an IOMGR abort */
 101 static afs_int32 sigsHandled;   /* sigmask(signo) is on if we handle signo */
 102 static int anySigsDelivered;            /* true if any have been delivered. */
 103 #ifndef AFS_NT40_ENV
 104 static struct sigaction oldActions[NSIG];       /* the old signal vectors */
 105 #endif
 106 static char *sigEvents[NSIG];           /* the event to do an LWP signal on */
 107 static int sigDelivered[NSIG];          /* True for signals delivered so far.
 108                                            This is an int array to make sure
 109                                            there are no conflicts when trying
 110                                            to write it */
 111 /* software 'signals' */
 112 #define NSOFTSIG                4
 113 static void *(*sigProc[NSOFTSIG])(void *);
 114 static void *sigRock[NSOFTSIG];
 115
 116
 117 static struct IoRequest *iorFreeList = 0;
 118
 119 static struct TM_Elem *Requests;        /* List of requests */
 120 static struct timeval iomgr_timeout;    /* global so signal handler can zap it */
 121
 122 /* stuff for debugging */
 123 static int iomgr_errno;
 124 static struct timeval iomgr_badtv;
 125 static PROCESS iomgr_badpid;
 126 static void SignalIO(int fds, fd_set *rfds, fd_set *wfds, fd_set *efs,
 127                     int code);
 128 static void SignalTimeout(int code, struct timeval *timeout);
 129
 130 /* fd_set pool managment.
 131  * Use the pool instead of creating fd_set's on the stack. fd_set's can be
 132  * 8K in size, so making three could put 24K in the limited space of an LWP
 133  * stack.
 134  */
 135 struct IOMGR_fd_set {
 136     struct IOMGR_fd_set *next;
 137 } *iomgrFreeFDSets = (struct IOMGR_fd_set*)0;
 138
 139 /* IOMGR_FreeFDSet
 140  * Return fd_set to the free list.
 141  */
 142 void IOMGR_FreeFDSet(fd_set *s)
 143 {
 144     struct IOMGR_fd_set *t = (struct IOMGR_fd_set *)s;
 145
 146     t->next = iomgrFreeFDSets;
 147     iomgrFreeFDSets = t;
 148 }
 149
 150 /* IOMGR_AllocFDSet
 151  * returns a zeroed fd_set or null if could not malloc one.
 152  */
 153 fd_set *IOMGR_AllocFDSet(void)
 154 {
 155     struct IOMGR_fd_set *t;
 156     if (iomgrFreeFDSets) {
 157         t =  iomgrFreeFDSets;
 158         iomgrFreeFDSets = iomgrFreeFDSets->next;
 159     }
 160     else {
 161         t = (struct IOMGR_fd_set *)malloc(sizeof(fd_set));
 162     }
 163     if (!t)
 164         return (fd_set*)0;
 165     else {
 166         FD_ZERO((fd_set*)t);
 167         return (fd_set*)t;
 168     }
 169 }
 170
 171 #define FreeRequest(x) ((x)->next = iorFreeList, iorFreeList = (x))
 172
 173 static struct IoRequest *NewRequest(void)
 174 {
 175     struct IoRequest *request;
 176
 177     if ((request=iorFreeList))
 178         iorFreeList = (struct IoRequest *) (request->next);
 179     else request = calloc(1, sizeof(struct IoRequest));
 180
 181     return request;
 182 }
 183
 184 #define Purge(list) FOR_ALL_ELTS(req, list, { free(req->BackPointer); })
 185
 186
 187 /* FD_SET support routines. All assume the fd_set size is a multiple of an int
 188  * so we can at least do logical operations on ints instead of chars.
 189  *
 190  * For each routine, nfds is the highest bit set in either fd_set, starting
 191  * with no bits == 0.
 192  */
 193 #ifdef AFS_NT40_ENV
 194 #define FD_N_ZERO(A, x) FD_ZERO(x)
 195 #else
 196 #define FDS_P_POS (sizeof(int)*8)
 197 #define INTS_PER_FDS(x) (((x)+(FDS_P_POS-1)) / FDS_P_POS)
 198 #define FD_N_ZERO(nfds, x) memset((char*)(x), 0, (INTS_PER_FDS(nfds))*sizeof(int))
 199 #endif
 200
 201 /* On Linux without __USE_XOPEN, we have __fds_bits. With __USE_XOPEN, or
 202  * non-Linux, we have fds_bits. */
 203 #if defined(AFS_LINUX22_ENV) && (__GLIBC_MINOR__ > 0) && !defined(__USE_XOPEN)
 204 # define FDS_BITS __fds_bits
 205 #else
 206 # define FDS_BITS fds_bits
 207 #endif
 208
 209 /* FDSetCmp - returns 1 if any bits in fd_set1 are also set in fd_set2.
 210  * If nfds is 0, or one of the fd_sets is null return 0 (since there is no bit
 211  * set in both fd_sets).
 212  */
 213 static int FDSetCmp(int nfds, fd_set *fd_set1, fd_set *fd_set2)
 214 {
 215     unsigned int i, j;
 216
 217     if (fd_set1 == (fd_set*)0 || fd_set2 == (fd_set*)0)
 218         return 0;
 219
 220 #ifdef AFS_NT40_ENV
 221     if (fd_set1->fd_count == 0 || fd_set2->fd_count == 0)
 222         return 0;
 223
 224     for (i=0; i<fd_set1->fd_count; i++) {
 225         for (j=0; j<fd_set2->fd_count; j++) {
 226         if (fd_set1->fd_array[i] == fd_set2->fd_array[j])
 227             return 1;
 228         }
 229     }
 230 #else
 231     if (nfds == 0)
 232         return 0;
 233
 234     j = INTS_PER_FDS(nfds);
 235     for (i=0; i<j; i++) {
 236         if (fd_set1->FDS_BITS[i] & fd_set2->FDS_BITS[i])
 237             return 1;
 238     }
 239 #endif
 240     return 0;
 241 }
 242
 243 /* FDSetSet - set bits from fd_set2 into fd_set1
 244  */
 245 static void FDSetSet(int nfds, fd_set *fd_set1, fd_set *fd_set2)
 246 {
 247     unsigned int i;
 248 #ifndef AFS_NT40_ENV
 249     unsigned int n;
 250 #endif
 251
 252     if (fd_set1 == (fd_set*)0 || fd_set2 == (fd_set*)0)
 253         return;
 254
 255 #ifdef AFS_NT40_ENV
 256     if (fd_set2->fd_count==0)
 257         return;
 258
 259     for (i=0; i<fd_set2->fd_count; i++)
 260         FD_SET(fd_set2->fd_array[i], fd_set1);
 261 #else
 262     if (nfds == 0)
 263         return;
 264
 265     for (i = 0, n = INTS_PER_FDS(nfds); i < n; i++) {
 266         fd_set1->FDS_BITS[i] |= fd_set2->FDS_BITS[i];
 267     }
 268 #endif
 269 }
 270
 271 /* FDSetAnd - fd_set1  <- fd_set1 & fd_set2.
 272  */
 273 #ifdef AFS_NT40_ENV
 274 static void FDSetAnd(int nfds, fd_set *fd_set1, fd_set *fd_set2)
 275 {
 276     unsigned int i;
 277     fd_set tmpset;
 278
 279     if (fd_set1 == NULL || fd_set1->fd_count == 0)
 280         return;
 281
 282     if (fd_set2 == NULL || fd_set2->fd_count == 0) {
 283         FD_ZERO(fd_set1);
 284     }
 285     else {
 286         FD_ZERO(&tmpset);
 287         for (i=0; i<fd_set2->fd_count; i++) {
 288             if (FD_ISSET(fd_set2->fd_array[i], fd_set1))
 289                 FD_SET(fd_set2->fd_array[i], &tmpset);
 290         }
 291         *fd_set1 = tmpset;
 292     }
 293 }
 294 #else
 295 static void FDSetAnd(int nfds, fd_set *fd_set1, fd_set *fd_set2)
 296 {
 297     int i, n;
 298
 299     if (nfds == 0 || fd_set1 == (fd_set*)0 || fd_set2 == (fd_set*)0)
 300         return;
 301
 302     n = INTS_PER_FDS(nfds);
 303     for (i=0; i<n; i++) {
 304         fd_set1->FDS_BITS[i] &= fd_set2->FDS_BITS[i];
 305     }
 306 }
 307 #endif
 308
 309 /* FDSetEmpty - return true if fd_set is empty
 310  */
 311 static int FDSetEmpty(int nfds, fd_set *fds)
 312 {
 313 #ifndef AFS_NT40_ENV
 314     int i, n;
 315
 316     if (nfds == 0)
 317         return 1;
 318 #endif
 319     if (fds == (fd_set*)0)
 320         return 1;
 321
 322 #ifdef AFS_NT40_ENV
 323     if (fds->fd_count == 0)
 324         return 1;
 325     else
 326         return 0;
 327 #else
 328     n = INTS_PER_FDS(nfds);
 329
 330     for (i=n-1; i>=0; i--) {
 331         if (fds->FDS_BITS[i])
 332             break;
 333     }
 334
 335     if (i>=0)
 336         return 0;
 337     else
 338         return 1;
 339 #endif
 340 }
 341
 342 /* The IOMGR process */
 343
 344 /*
 345  * Important invariant: process->iomgrRequest is null iff request not in timer
 346  * queue.
 347  * also, request->pid is valid while request is in queue,
 348  * also, don't signal selector while request in queue, since selector frees
 349  *  request.
 350  */
 351
 352 /* These are not declared in IOMGR so that they don't use up 6K of stack. */
 353 static fd_set IOMGR_readfds, IOMGR_writefds, IOMGR_exceptfds;
 354 static int IOMGR_nfds = 0;
 355
 356 static void *IOMGR(void *dummy)
 357 {
 358     for (;;) {
 359         int code;
 360         struct TM_Elem *earliest;
 361         struct timeval timeout, junk;
 362         bool woke_someone;
 363
 364         FD_ZERO(&IOMGR_readfds);
 365         FD_ZERO(&IOMGR_writefds);
 366         FD_ZERO(&IOMGR_exceptfds);
 367         IOMGR_nfds = 0;
 368
 369         /* Wake up anyone who has expired or who has received a
 370            Unix signal between executions.  Keep going until we
 371            run out. */
 372         do {
 373             woke_someone = FALSE;
 374             /* Wake up anyone waiting on signals. */
 375             /* Note: SignalSignals() may yield! */
 376             if (anySigsDelivered && SignalSignals ())
 377                 woke_someone = TRUE;
 378             FT_GetTimeOfDay(&junk, 0);    /* force accurate time check */
 379             TM_Rescan(Requests);
 380             for (;;) {
 381                 struct IoRequest *req;
 382                 struct TM_Elem *expired;
 383                 expired = TM_GetExpired(Requests);
 384                 if (expired == NULL) break;
 385                 woke_someone = TRUE;
 386                 req = (struct IoRequest *) expired -> BackPointer;
 387 #ifdef DEBUG
 388                 if (lwp_debug != 0) puts("[Polling SELECT]");
 389 #endif /* DEBUG */
 390                 /* no data ready */
 391                 if (req->readfds)   FD_N_ZERO(req->nfds, req->readfds);
 392                 if (req->writefds)  FD_N_ZERO(req->nfds, req->writefds);
 393                 if (req->exceptfds) FD_N_ZERO(req->nfds, req->exceptfds);
 394                 req->nfds = 0;
 395                 req->result = 0; /* no fds ready */
 396                 TM_Remove(Requests, &req->timeout);
 397 #ifdef DEBUG
 398                 req -> timeout.Next = (struct TM_Elem *) 2;
 399                 req -> timeout.Prev = (struct TM_Elem *) 2;
 400 #endif /* DEBUG */
 401                 LWP_QSignal(req->pid);
 402                 req->pid->iomgrRequest = 0;
 403             }
 404
 405             if (woke_someone) LWP_DispatchProcess();
 406         } while (woke_someone);
 407
 408         /* Collect requests & update times */
 409         FD_ZERO(&IOMGR_readfds);
 410         FD_ZERO(&IOMGR_writefds);
 411         FD_ZERO(&IOMGR_exceptfds);
 412         IOMGR_nfds = 0;
 413
 414         FOR_ALL_ELTS(r, Requests, {
 415             struct IoRequest *req;
 416             req = (struct IoRequest *) r -> BackPointer;
 417             FDSetSet(req->nfds, &IOMGR_readfds,   req->readfds);
 418             FDSetSet(req->nfds, &IOMGR_writefds,  req->writefds);
 419             FDSetSet(req->nfds, &IOMGR_exceptfds, req->exceptfds);
 420             if (req->nfds > IOMGR_nfds)
 421                 IOMGR_nfds = req->nfds;
 422         })
 423         earliest = TM_GetEarliest(Requests);
 424         if (earliest != NULL) {
 425             timeout = earliest -> TimeLeft;
 426
 427
 428             /* Do select */
 429 #ifdef DEBUG
 430             if (lwp_debug != 0) {
 431 #ifdef AFS_NT40_ENV
 432                 int idbg;
 433                 printf("[Read Select:");
 434                 if (IOMGR_readfds.fd_count == 0)
 435                     printf(" none]\n");
 436                 else {
 437                     for (idbg=0; idbg<IOMGR_readfds.fd_count; idbg++)
 438                         printf(" %d", IOMGR_readfds.fd_array[idbg]);
 439                     printf("]\n");
 440                 }
 441                 printf("[Write Select:");
 442                 if (IOMGR_writefds.fd_count == 0)
 443                     printf(" none]\n");
 444                 else {
 445                     for (idbg=0; idbg<IOMGR_writefds.fd_count; idbg++)
 446                         printf(" %d", IOMGR_writefds.fd_array[idbg]);
 447                     printf("]\n");
 448                 }
 449                 printf("[Except Select:");
 450                 if (IOMGR_exceptfds.fd_count == 0)
 451                     printf(" none]\n");
 452                 else {
 453                     for (idbg=0; idbg<IOMGR_exceptfds.fd_count; idbg++)
 454                         printf(" %d", IOMGR_exceptfds.fd_array[idbg]);
 455                     printf("]\n");
 456                 }
 457 #else
 458                 /* Only prints first 32. */
 459                 printf("[select(%d, 0x%x, 0x%x, 0x%x, ", IOMGR_nfds,
 460                        *(int*)&IOMGR_readfds, *(int*)&IOMGR_writefds,
 461                        *(int*)&IOMGR_exceptfds);
 462 #endif /* AFS_NT40_ENV */
 463                 if (timeout.tv_sec == -1 && timeout.tv_usec == -1)
 464                     puts("INFINITE)]");
 465                 else
 466                     printf("<%d, %d>)]\n", timeout.tv_sec, timeout.tv_usec);
 467             }
 468 #endif /* DEBUG */
 469             iomgr_timeout = timeout;
 470             if (timeout.tv_sec == -1 && timeout.tv_usec == -1) {
 471                 /* infinite, sort of */
 472                 iomgr_timeout.tv_sec = 100000000;
 473                 iomgr_timeout.tv_usec = 0;
 474             }
 475 #if defined(AFS_NT40_ENV) || defined(AFS_LINUX24_ENV)
 476             /* On NT, signals don't interrupt a select call. So this can potentially
 477              * lead to long wait times before a signal is honored. To avoid this we
 478              * dont do select() for longer than IOMGR_MAXWAITTIME (5 secs) */
 479             /* Whereas Linux seems to sometimes "lose" signals */
 480             if (iomgr_timeout.tv_sec > (IOMGR_MAXWAITTIME - 1)) {
 481               iomgr_timeout.tv_sec = IOMGR_MAXWAITTIME;
 482               iomgr_timeout.tv_usec = 0;
 483             }
 484 #endif /* NT40 */
 485
 486             /* Check one last time for a signal delivery.  If one comes after
 487                this, the signal handler will set iomgr_timeout to zero, causing
 488                the select to return immediately.  The timer package won't return
 489                a zero timeval because all of those guys were handled above.
 490
 491                I'm assuming that the kernel masks signals while it's picking up
 492                the parameters to select.  This may a bad assumption.  -DN */
 493             if (anySigsDelivered)
 494                 continue;       /* go to the top and handle them. */
 495
 496 #ifdef AFS_NT40_ENV
 497             if (IOMGR_readfds.fd_count == 0 && IOMGR_writefds.fd_count == 0
 498                 && IOMGR_exceptfds.fd_count == 0) {
 499                 DWORD stime;
 500                 code = 0;
 501                 if (iomgr_timeout.tv_sec || iomgr_timeout.tv_usec) {
 502                     stime = iomgr_timeout.tv_sec * 1000
 503                         + iomgr_timeout.tv_usec/1000;
 504                     if (!stime)
 505                         stime = 1;
 506                     Sleep(stime);
 507                 }
 508             }
 509             else
 510 #endif
 511                 {    /* select runs much faster if 0's are passed instead of &0s */
 512                     code = select(IOMGR_nfds,
 513                                   (FDSetEmpty(IOMGR_nfds, &IOMGR_readfds)) ?
 514                                   (fd_set*)0 : &IOMGR_readfds,
 515                                   (FDSetEmpty(IOMGR_nfds, &IOMGR_writefds)) ?
 516                                   (fd_set*)0 : &IOMGR_writefds,
 517                                   (FDSetEmpty(IOMGR_nfds, &IOMGR_exceptfds)) ?
 518                                   (fd_set*)0 : &IOMGR_exceptfds,
 519                                   &iomgr_timeout);
 520                 }
 521
 522             if (code < 0) {
 523                int e=1;
 524
 525 #if defined(AFS_SUN_ENV)
 526                /* Tape drives on Sun boxes do not support select and return ENXIO */
 527                if (errno == ENXIO) e=0, code=1;
 528 #endif
 529 #if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV) || defined(AFS_AIX32_ENV)
 530                /* For SGI and SVR4 - poll & select can return EAGAIN ... */
 531                if (errno == EAGAIN) e=0;
 532 #endif
 533 #if defined(AFS_SUN5_ENV)
 534                /* On sun4x_55, select doesn't block signal. It could be
 535                   interupted by a signal that changes iomgr_timeout, and
 536                   then select returns with EINVAL. In this case, we need
 537                   to retry.
 538                 */
 539                if (errno==EINVAL && anySigsDelivered)
 540                    e = 0;
 541 #endif /* AFS_SUN5_ENV */
 542
 543                if ((errno != EINTR) && e) {
 544 #ifndef AFS_NT40_ENV
 545                   int i;
 546                   for(i=0; i<FD_SETSIZE; i++) {
 547                      if (fcntl(i, F_GETFD, 0) < 0 && errno == EBADF)
 548                          FD_SET(i, &openMask);
 549                   }
 550 #endif
 551                   iomgr_errno = errno;
 552                   opr_abort();
 553                }
 554             }
 555
 556             /* See what happened */
 557             if (code > 0) {
 558                 /* Action -- wake up everyone involved */
 559                 SignalIO(IOMGR_nfds, &IOMGR_readfds, &IOMGR_writefds,
 560                          &IOMGR_exceptfds, code);
 561             }
 562             else if (code == 0
 563                 && (iomgr_timeout.tv_sec != 0 || iomgr_timeout.tv_usec != 0)) {
 564                 /* Real timeout only if signal handler hasn't set
 565                    iomgr_timeout to zero. */
 566
 567 #if defined(AFS_NT40_ENV) || defined(AFS_LINUX24_ENV)
 568                 /* On NT, real timeout only if above and if iomgr_timeout
 569                  * interval is equal to timeout interval (i.e., not adjusted
 570                  * to check for pseudo-signals).
 571                  */
 572                 /* And also for Linux as above */
 573                 if (iomgr_timeout.tv_sec  != timeout.tv_sec ||
 574                     iomgr_timeout.tv_usec != timeout.tv_usec) {
 575                     /* signal check interval timed out; not real timeout */
 576                     continue;
 577                 }
 578 #endif /* AFS_NT40_ENV */
 579                 FT_GetTimeOfDay(&junk, 0);
 580                 SignalTimeout(code, &timeout);
 581             }
 582         }
 583         LWP_DispatchProcess();
 584     }
 585     return (void *)-1; /* keeps compilers happy. */
 586 }
 587
 588 /************************\
 589 *                        *
 590 *  Signalling routines   *
 591 *                        *
 592 \************************/
 593
 594 static void SignalIO(int fds, fd_set *readfds, fd_set *writefds,
 595                      fd_set *exceptfds, int code)
 596 {
 597     int nfds;
 598     /* Look at everyone who's bit mask was affected */
 599     FOR_ALL_ELTS(r, Requests, {
 600         struct IoRequest *req;
 601         PROCESS pid;
 602         req = (struct IoRequest *) r -> BackPointer;
 603         nfds = MIN(fds, req->nfds);
 604         if (FDSetCmp(nfds, req->readfds, readfds) ||
 605             FDSetCmp(nfds, req->writefds, writefds) ||
 606             FDSetCmp(nfds, req->exceptfds, exceptfds)) {
 607             /* put ready fd's into request. */
 608             FDSetAnd(nfds, req->readfds, readfds);
 609             FDSetAnd(nfds, req->writefds, writefds);
 610             FDSetAnd(nfds, req->exceptfds, exceptfds);
 611             req -> result = code;
 612             TM_Remove(Requests, &req->timeout);
 613             LWP_QSignal(pid=req->pid);
 614             pid->iomgrRequest = 0;
 615         }
 616     })
 617 }
 618
 619 static void SignalTimeout(int code, struct timeval *timeout)
 620 {
 621     /* Find everyone who has specified timeout */
 622     FOR_ALL_ELTS(r, Requests, {
 623         struct IoRequest *req;
 624         PROCESS pid;
 625         req = (struct IoRequest *) r -> BackPointer;
 626         if (TM_eql(&r->TimeLeft, timeout)) {
 627             req -> result = code;
 628             TM_Remove(Requests, &req->timeout);
 629             LWP_QSignal(pid=req->pid);
 630             pid->iomgrRequest = 0;
 631         } else
 632             return;
 633     })
 634 }
 635
 636 /*****************************************************\
 637 *                                                     *
 638 *  Signal handling routine (not to be confused with   *
 639 *  signalling routines, above).                       *
 640 *                                                     *
 641 \*****************************************************/
 642 static void SigHandler (int signo)
 643 {
 644     if (badsig(signo) || (sigsHandled & mysigmask(signo)) == 0)
 645         return;         /* can't happen. */
 646     sigDelivered[signo] = TRUE;
 647     anySigsDelivered = TRUE;
 648     /* Make sure that the IOMGR process doesn't pause on the select. */
 649     iomgr_timeout.tv_sec = 0;
 650     iomgr_timeout.tv_usec = 0;
 651 }
 652
 653 /* Alright, this is the signal signalling routine.  It delivers LWP signals
 654    to LWPs waiting on Unix signals. NOW ALSO CAN YIELD!! */
 655 static int SignalSignals (void)
 656 {
 657     bool gotone = FALSE;
 658     int i;
 659     void *(*p)(void *);
 660     afs_int32 stackSize;
 661
 662     anySigsDelivered = FALSE;
 663
 664     /* handle software signals */
 665     stackSize = (AFS_LWP_MINSTACKSIZE < lwp_MaxStackSeen? lwp_MaxStackSeen : AFS_LWP_MINSTACKSIZE);
 666     for (i=0; i < NSOFTSIG; i++) {
 667         PROCESS pid;
 668         if ((p=sigProc[i])) /* This yields!!! */
 669             LWP_CreateProcess2(p, stackSize, LWP_NORMAL_PRIORITY,
 670                                sigRock[i], "SignalHandler", &pid);
 671         sigProc[i] = 0;
 672     }
 673
 674     for (i = 1; i <= NSIG; ++i)  /* forall !badsig(i) */
 675         if ((sigsHandled & mysigmask(i)) && sigDelivered[i] == TRUE) {
 676             sigDelivered[i] = FALSE;
 677             LWP_NoYieldSignal (sigEvents[i]);
 678             gotone = TRUE;
 679         }
 680     return gotone;
 681 }
 682
 683
 684 /***************************\
 685 *                           *
 686 *  User-callable routines   *
 687 *                           *
 688 \***************************/
 689
 690
 691 /* Keep IOMGR process id */
 692 static PROCESS IOMGR_Id = NULL;
 693
 694 int IOMGR_SoftSig(void *(*aproc)(void *), void *arock)
 695 {
 696     int i;
 697     for (i=0;i<NSOFTSIG;i++) {
 698         if (sigProc[i] == 0) {
 699             /* a free entry */
 700             sigProc[i] = aproc;
 701             sigRock[i] = arock;
 702             anySigsDelivered = TRUE;
 703             iomgr_timeout.tv_sec = 0;
 704             iomgr_timeout.tv_usec = 0;
 705             return 0;
 706         }
 707     }
 708     return -1;
 709 }
 710
 711
 712 int IOMGR_Initialize(void)
 713 {
 714     PROCESS pid;
 715
 716     /* If lready initialized, just return */
 717     if (IOMGR_Id != NULL) return LWP_SUCCESS;
 718
 719     /* Init LWP if someone hasn't yet. */
 720     if (LWP_InitializeProcessSupport (LWP_NORMAL_PRIORITY, &pid) != LWP_SUCCESS)
 721         return -1;
 722
 723     /* Initialize request lists */
 724     if (TM_Init(&Requests) < 0) return -1;
 725
 726     /* Initialize signal handling stuff. */
 727     sigsHandled = 0;
 728     anySigsDelivered = TRUE; /* A soft signal may have happened before
 729         IOMGR_Initialize:  so force a check for signals regardless */
 730
 731     return LWP_CreateProcess(IOMGR, AFS_LWP_MINSTACKSIZE, 0, (void *) 0,
 732                              "IO MANAGER", &IOMGR_Id);
 733 }
 734
 735 int IOMGR_Finalize(void)
 736 {
 737     int status;
 738
 739     Purge(Requests)
 740     TM_Final(&Requests);
 741     status = LWP_DestroyProcess(IOMGR_Id);
 742     IOMGR_Id = NULL;
 743     return status;
 744 }
 745
 746 /* signal I/O for anyone who is waiting for a FD or a timeout; not too cheap,
 747  * since forces select and timeofday check */
 748 int IOMGR_Poll(void) {
 749     fd_set *readfds, *writefds, *exceptfds;
 750     afs_int32 code;
 751     struct timeval tv;
 752     int fds;
 753
 754     FT_GetTimeOfDay(&tv, 0);    /* force accurate time check */
 755     TM_Rescan(Requests);
 756     for (;;) {
 757         struct IoRequest *req;
 758         struct TM_Elem *expired;
 759         expired = TM_GetExpired(Requests);
 760         if (expired == NULL) break;
 761         req = (struct IoRequest *) expired -> BackPointer;
 762 #ifdef DEBUG
 763         if (lwp_debug != 0) puts("[Polling SELECT]");
 764 #endif /* DEBUG */
 765         /* no data ready */
 766         if (req->readfds)   FD_N_ZERO(req->nfds, req->readfds);
 767         if (req->writefds)  FD_N_ZERO(req->nfds, req->writefds);
 768         if (req->exceptfds) FD_N_ZERO(req->nfds, req->exceptfds);
 769         req->nfds = 0;
 770         req->result = 0; /* no fds ready */
 771         TM_Remove(Requests, &req->timeout);
 772 #ifdef DEBUG
 773         req -> timeout.Next = (struct TM_Elem *) 2;
 774         req -> timeout.Prev = (struct TM_Elem *) 2;
 775 #endif /* DEBUG */
 776         LWP_QSignal(req->pid);
 777         req->pid->iomgrRequest = 0;
 778     }
 779
 780     /* Collect requests & update times */
 781     readfds = IOMGR_AllocFDSet();
 782     writefds = IOMGR_AllocFDSet();
 783     exceptfds = IOMGR_AllocFDSet();
 784     if (!(readfds && writefds && exceptfds)) {
 785         fprintf(stderr, "IOMGR_Poll: Could not malloc space for fd_sets.\n");
 786         fflush(stderr);
 787     }
 788
 789     fds = 0;
 790
 791     FOR_ALL_ELTS(r, Requests, {
 792         struct IoRequest *req;
 793         req = (struct IoRequest *) r -> BackPointer;
 794         FDSetSet(req->nfds, readfds,   req->readfds);
 795         FDSetSet(req->nfds, writefds,  req->writefds);
 796         FDSetSet(req->nfds, exceptfds, req->exceptfds);
 797         if (fds < req->nfds)
 798             fds = req->nfds;
 799     })
 800
 801     tv.tv_sec = 0;
 802     tv.tv_usec = 0;
 803 #ifdef AFS_NT40_ENV
 804     code = -1;
 805     if (readfds->fd_count == 0 && writefds->fd_count == 0
 806         && exceptfds->fd_count == 0)
 807 #endif
 808         code = select(fds, readfds, writefds, exceptfds, &tv);
 809     if (code > 0) {
 810         SignalIO(fds, readfds, writefds, exceptfds, code);
 811     }
 812
 813     if (readfds) IOMGR_FreeFDSet(readfds);
 814     if (writefds) IOMGR_FreeFDSet(writefds);
 815     if (exceptfds) IOMGR_FreeFDSet(exceptfds);
 816
 817
 818     LWP_DispatchProcess();  /* make sure others run */
 819     LWP_DispatchProcess();
 820     return 0;
 821 }
 822
 823 int IOMGR_Select(int fds, fd_set *readfds, fd_set *writefds,
 824                  fd_set *exceptfds, struct timeval *timeout)
 825 {
 826     struct IoRequest *request;
 827     int result;
 828
 829 #ifndef AFS_NT40_ENV
 830     if(fds > FD_SETSIZE) {
 831         fprintf(stderr, "IOMGR_Select: fds=%d, more than max %d\n",
 832                 fds, FD_SETSIZE);
 833         fflush(stderr);
 834         opr_abort();
 835     }
 836 #endif
 837
 838     /* See if polling request. If so, handle right here */
 839     if (timeout != NULL) {
 840         if (timeout->tv_sec == 0 && timeout->tv_usec == 0) {
 841             int code;
 842 #ifdef DEBUG
 843             if (lwp_debug != 0) puts("[Polling SELECT]");
 844 #endif /* DEBUG */
 845 #if     defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV) || defined(AFS_AIX32_ENV) || defined(AFS_NT40_ENV)
 846 again:
 847 #endif
 848             code = select(fds, readfds, writefds, exceptfds, timeout);
 849 #if     defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_OSF_ENV) || defined(AFS_AIX32_ENV)
 850             /*
 851              * For SGI and SVR4 - poll & select can return EAGAIN ...
 852              */
 853             /*
 854              * this is basically for SGI, but I believe stock SVR4 (Solaris?)
 855              * can also get this error return
 856              */
 857             if (code < 0 && errno == EAGAIN)
 858                 goto again;
 859 #endif
 860 #ifdef AFS_NT40_ENV
 861             if (code == SOCKET_ERROR) {
 862                 if (WSAGetLastError() == WSAEINPROGRESS)
 863                     goto again;
 864
 865                 code = -1;
 866             }
 867 #endif
 868             return (code > 1 ? 1 : code);
 869         }
 870     }
 871
 872     /* Construct request block & insert */
 873     request = NewRequest(); /* zeroes fd_set's */
 874     if (readfds && !FDSetEmpty(fds, readfds))
 875         request->readfds = readfds;
 876     if (writefds && !FDSetEmpty(fds, writefds))
 877         request->writefds = writefds;
 878     if (exceptfds && !FDSetEmpty(fds, exceptfds))
 879         request->exceptfds = exceptfds;
 880     request->nfds = fds;
 881
 882     if (timeout == NULL) {
 883         request -> timeout.TotalTime.tv_sec = -1;
 884         request -> timeout.TotalTime.tv_usec = -1;
 885     } else {
 886         request -> timeout.TotalTime = *timeout;
 887         /* check for bad request */
 888         if (timeout->tv_sec < 0 || timeout->tv_usec < 0 || timeout->tv_usec > 999999) {
 889             /* invalid arg */
 890             iomgr_badtv = *timeout;
 891             iomgr_badpid = LWP_ActiveProcess;
 892             /* now fixup request */
 893             if(request->timeout.TotalTime.tv_sec < 0)
 894                 request->timeout.TotalTime.tv_sec = 1;
 895             request->timeout.TotalTime.tv_usec = 100000;
 896         }
 897     }
 898
 899     request -> timeout.BackPointer = (char *) request;
 900
 901     /* Insert my PID in case of IOMGR_Cancel */
 902     request -> pid = LWP_ActiveProcess;
 903     LWP_ActiveProcess -> iomgrRequest = request;
 904
 905 #ifdef DEBUG
 906     request -> timeout.Next = (struct TM_Elem *) 1;
 907     request -> timeout.Prev = (struct TM_Elem *) 1;
 908 #endif /* DEBUG */
 909     TM_Insert(Requests, &request->timeout);
 910
 911     /* Wait for action */
 912     LWP_QWait();
 913
 914     /* Update parameters & return */
 915     result = request -> result;
 916
 917     FreeRequest(request);
 918     return (result > 1 ? 1 : result);
 919 }
 920
 921 int IOMGR_Cancel(PROCESS pid)
 922 {
 923     struct IoRequest *request;
 924
 925     if ((request = pid->iomgrRequest) == 0) return -1;  /* Pid not found */
 926
 927     if (request->readfds)   FD_N_ZERO(request->nfds, request->readfds);
 928     if (request->writefds)  FD_N_ZERO(request->nfds, request->writefds);
 929     if (request->exceptfds) FD_N_ZERO(request->nfds, request->exceptfds);
 930     request->nfds = 0;
 931
 932     request -> result = -2;
 933     TM_Remove(Requests, &request->timeout);
 934 #ifdef DEBUG
 935     request -> timeout.Next = (struct TM_Elem *) 5;
 936     request -> timeout.Prev = (struct TM_Elem *) 5;
 937 #endif /* DEBUG */
 938     LWP_QSignal(request->pid);
 939     pid->iomgrRequest = 0;
 940
 941     return 0;
 942 }
 943
 944 #ifndef AFS_NT40_ENV
 945 /* Cause delivery of signal signo to result in a LWP_SignalProcess of
 946    event. */
 947 int IOMGR_Signal (int signo, char *event)
 948 {
 949     struct sigaction sa;
 950
 951     if (badsig(signo))
 952         return LWP_EBADSIG;
 953     if (event == NULL)
 954         return LWP_EBADEVENT;
 955     sa.sa_handler = SigHandler;
 956     sigfillset(&sa.sa_mask);    /* mask all signals */
 957     sa.sa_flags = 0;
 958     sigsHandled |= mysigmask(signo);
 959     sigEvents[signo] = event;
 960     sigDelivered[signo] = FALSE;
 961     if (sigaction (signo, &sa, &oldActions[signo]) == -1)
 962         return LWP_ESYSTEM;
 963     return LWP_SUCCESS;
 964 }
 965
 966 /* Stop handling occurrences of signo. */
 967 int IOMGR_CancelSignal (int signo)
 968 {
 969     if (badsig(signo) || (sigsHandled & mysigmask(signo)) == 0)
 970         return LWP_EBADSIG;
 971     sigaction (signo, &oldActions[signo], NULL);
 972     sigsHandled &= ~mysigmask(signo);
 973     return LWP_SUCCESS;
 974 }
 975 #endif /* AFS_NT40_ENV */
 976 /* This routine calls select is a fashion that simulates the standard sleep routine */
 977 void IOMGR_Sleep (int seconds)
 978 {
 979     struct timeval timeout;
 980
 981     timeout.tv_sec = seconds;
 982     timeout.tv_usec = 0;
 983     IOMGR_Select(0, 0, 0, 0, &timeout);
 984 }