src/vol/fssync.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         System:         VICE-TWO
  12         Module:         fssync.c
  13         Institution:    The Information Technology Center, Carnegie-Mellon University
  14
  15  */
  16 #ifdef notdef
  17
  18 /* All this is going away in early 1989 */
  19 int newVLDB;                    /* Compatibility flag */
  20
  21 #endif
  22 static int newVLDB = 1;
  23
  24
  25 #ifndef AFS_PTHREAD_ENV
  26 #define USUAL_PRIORITY (LWP_MAX_PRIORITY - 2)
  27
  28 /*
  29  * stack size increased from 8K because the HP machine seemed to have trouble
  30  * with the smaller stack
  31  */
  32 #define USUAL_STACK_SIZE        (24 * 1024)
  33 #endif /* !AFS_PTHREAD_ENV */
  34
  35 /*
  36    fsync.c
  37    File server synchronization with external volume utilities.
  38  */
  39
  40 /* This controls the size of an fd_set; it must be defined early before
  41  * the system headers define that type and the macros that operate on it.
  42  * Its value should be as large as the maximum file descriptor limit we
  43  * are likely to run into on any platform.  Right now, that is 65536
  44  * which is the default hard fd limit on Solaris 9 */
  45 #define FD_SETSIZE 65536
  46
  47 #include <afsconfig.h>
  48 #include <afs/param.h>
  49
  50 RCSID
  51     ("$Header$");
  52
  53 #include <sys/types.h>
  54 #include <stdio.h>
  55 #ifdef AFS_NT40_ENV
  56 #include <winsock2.h>
  57 #include <time.h>
  58 #else
  59 #include <sys/param.h>
  60 #include <sys/socket.h>
  61 #include <netinet/in.h>
  62 #include <netdb.h>
  63 #include <sys/time.h>
  64 #endif
  65 #include <errno.h>
  66 #ifdef AFS_PTHREAD_ENV
  67 #include <assert.h>
  68 #else /* AFS_PTHREAD_ENV */
  69 #include <afs/assert.h>
  70 #endif /* AFS_PTHREAD_ENV */
  71 #include <signal.h>
  72
  73 #ifdef HAVE_STRING_H
  74 #include <string.h>
  75 #else
  76 #ifdef HAVE_STRINGS_H
  77 #include <strings.h>
  78 #endif
  79 #endif
  80
  81
  82 #include <rx/xdr.h>
  83 #include <afs/afsint.h>
  84 #include "nfs.h"
  85 #include <afs/errors.h>
  86 #include "fssync.h"
  87 #include "lwp.h"
  88 #include "lock.h"
  89 #include <afs/afssyscalls.h>
  90 #include "ihandle.h"
  91 #include "vnode.h"
  92 #include "volume.h"
  93 #include "partition.h"
  94
  95 /*@printflike@*/ extern void Log(const char *format, ...);
  96
  97 #ifdef osi_Assert
  98 #undef osi_Assert
  99 #endif
 100 #define osi_Assert(e) (void)(e)
 101
 102 int (*V_BreakVolumeCallbacks) ();
 103
 104 #define MAXHANDLERS     4       /* Up to 4 clients; must be at least 2, so that
 105                                  * move = dump+restore can run on single server */
 106 #define MAXOFFLINEVOLUMES 30    /* This needs to be as big as the maximum
 107                                  * number that would be offline for 1 operation.
 108                                  * Current winner is salvage, which needs all
 109                                  * cloned read-only copies offline when salvaging
 110                                  * a single read-write volume */
 111
 112 #define MAX_BIND_TRIES  5       /* Number of times to retry socket bind */
 113
 114
 115 struct offlineInfo {
 116     VolumeId volumeID;
 117     char partName[16];
 118 };
 119
 120 static struct offlineInfo OfflineVolumes[MAXHANDLERS][MAXOFFLINEVOLUMES];
 121
 122 static FS_sd = -1;              /* Client socket for talking to file server */
 123 static AcceptSd = -1;           /* Socket used by server for accepting connections */
 124
 125 static int getport();
 126
 127 struct command {
 128     bit32 command;
 129     bit32 reason;
 130     VolumeId volume;
 131     char partName[16];          /* partition name, e.g. /vicepa */
 132 };
 133
 134 /* Forward declarations */
 135 static void FSYNC_sync();
 136 static void FSYNC_newconnection();
 137 static void FSYNC_com();
 138 static void FSYNC_Drop();
 139 static void AcceptOn();
 140 static void AcceptOff();
 141 static void InitHandler();
 142 static void CallHandler(fd_set * fdsetp);
 143 static int AddHandler();
 144 static int FindHandler();
 145 static int FindHandler_r();
 146 static int RemoveHandler();
 147 static void GetHandler(fd_set * fdsetp, int *maxfdp);
 148
 149 extern int LogLevel;
 150
 151 /*
 152  * This lock controls access to the handler array. The overhead
 153  * is minimal in non-preemptive environments.
 154  */
 155 struct Lock FSYNC_handler_lock;
 156
 157 int
 158 FSYNC_clientInit(void)
 159 {
 160     struct sockaddr_in addr;
 161     /* I can't believe the following is needed for localhost connections!! */
 162     static time_t backoff[] =
 163         { 3, 3, 3, 5, 5, 5, 7, 15, 16, 24, 32, 40, 48, 0 };
 164     time_t *timeout = &backoff[0];
 165
 166     for (;;) {
 167         FS_sd = getport(&addr);
 168         if (connect(FS_sd, (struct sockaddr *)&addr, sizeof(addr)) >= 0)
 169             return 1;
 170 #if defined(AFS_SGI_ENV)
 171         /* down with worthless error messages! */
 172         if (!*timeout) {
 173             perror("FSYNC_clientInit failed (after many retries)");
 174             break;
 175         }
 176 #else
 177         if (!*timeout)
 178             break;
 179         if (!(*timeout & 1))
 180             perror("FSYNC_clientInit temporary failure (will retry)");
 181 #endif
 182         FSYNC_clientFinis();
 183         sleep(*timeout++);
 184     }
 185     perror("FSYNC_clientInit failed (giving up!)");
 186     return 0;
 187 }
 188
 189 void
 190 FSYNC_clientFinis(void)
 191 {
 192 #ifdef AFS_NT40_ENV
 193     closesocket(FS_sd);
 194 #else
 195     close(FS_sd);
 196 #endif
 197     FS_sd = -1;
 198     Lock_Destroy(&FSYNC_handler_lock);
 199 }
 200
 201 int
 202 FSYNC_askfs(VolumeId volume, char *partName, int com, int reason)
 203 {
 204     byte response;
 205     struct command command;
 206     int n;
 207     command.volume = volume;
 208     command.command = com;
 209     command.reason = reason;
 210     if (partName)
 211         strcpy(command.partName, partName);
 212     else
 213         command.partName[0] = 0;
 214     assert(FS_sd != -1);
 215     VFSYNC_LOCK
 216 #ifdef AFS_NT40_ENV
 217     if (send(FS_sd, (char *)&command, sizeof(command), 0) != sizeof(command)) {
 218         printf("FSYNC_askfs: write to file server failed\n");
 219         response = FSYNC_DENIED;
 220         goto done;
 221     }
 222     while ((n = recv(FS_sd, &response, 1, 0)) != 1) {
 223         if (n == 0 || WSAEINTR != WSAGetLastError()) {
 224             printf("FSYNC_askfs: No response from file server\n");
 225             response = FSYNC_DENIED;
 226             goto done;
 227         }
 228     }
 229 #else
 230     if (write(FS_sd, &command, sizeof(command)) != sizeof(command)) {
 231         printf("FSYNC_askfs: write to file server failed\n");
 232         response = FSYNC_DENIED;
 233         goto done;
 234     }
 235     while ((n = read(FS_sd, &response, 1)) != 1) {
 236         if (n == 0 || errno != EINTR) {
 237             printf("FSYNC_askfs: No response from file server\n");
 238             response = FSYNC_DENIED;
 239             goto done;
 240         }
 241     }
 242 #endif
 243     if (response == 0) {
 244         printf
 245             ("FSYNC_askfs: negative response from file server; volume %u, command %d\n",
 246              command.volume, (int)command.command);
 247     }
 248  done:
 249     VFSYNC_UNLOCK
 250
 251     return response;
 252 }
 253
 254 void
 255 FSYNC_fsInit(void)
 256 {
 257 #ifdef AFS_PTHREAD_ENV
 258     pthread_t tid;
 259     pthread_attr_t tattr;
 260     assert(pthread_attr_init(&tattr) == 0);
 261     assert(pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED) == 0);
 262     assert(pthread_create(&tid, &tattr, FSYNC_sync, NULL) == 0);
 263 #else /* AFS_PTHREAD_ENV */
 264     PROCESS pid;
 265     assert(LWP_CreateProcess
 266            (FSYNC_sync, USUAL_STACK_SIZE, USUAL_PRIORITY, (void *)0,
 267             "FSYNC_sync", &pid) == LWP_SUCCESS);
 268 #endif /* AFS_PTHREAD_ENV */
 269 }
 270
 271 static int
 272 getport(struct sockaddr_in *addr)
 273 {
 274     int sd;
 275
 276     memset(addr, 0, sizeof(*addr));
 277     assert((sd = socket(AF_INET, SOCK_STREAM, 0)) >= 0);
 278 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
 279     addr->sin_len = sizeof(struct sockaddr_in);
 280 #endif
 281     addr->sin_addr.s_addr = htonl(0x7f000001);
 282     addr->sin_family = AF_INET; /* was localhost->h_addrtype */
 283     addr->sin_port = htons(2040);       /* XXXX htons not _really_ neccessary */
 284
 285     return sd;
 286 }
 287
 288 static fd_set FSYNC_readfds;
 289
 290 static void
 291 FSYNC_sync()
 292 {
 293     struct sockaddr_in addr;
 294     int on = 1;
 295     extern VInit;
 296     int code;
 297     int numTries;
 298 #ifdef AFS_PTHREAD_ENV
 299     int tid;
 300 #endif
 301
 302 #ifndef AFS_NT40_ENV
 303     (void)signal(SIGPIPE, SIG_IGN);
 304 #endif
 305
 306 #ifdef AFS_PTHREAD_ENV
 307     /* set our 'thread-id' so that the host hold table works */
 308     MUTEX_ENTER(&rx_stats_mutex);       /* protects rxi_pthread_hinum */
 309     tid = ++rxi_pthread_hinum;
 310     MUTEX_EXIT(&rx_stats_mutex);
 311     pthread_setspecific(rx_thread_id_key, (void *)tid);
 312     Log("Set thread id %d for FSYNC_sync\n", tid);
 313 #endif /* AFS_PTHREAD_ENV */
 314
 315     while (!VInit) {
 316         /* Let somebody else run until level > 0.  That doesn't mean that
 317          * all volumes have been attached. */
 318 #ifdef AFS_PTHREAD_ENV
 319         pthread_yield();
 320 #else /* AFS_PTHREAD_ENV */
 321         LWP_DispatchProcess();
 322 #endif /* AFS_PTHREAD_ENV */
 323     }
 324     AcceptSd = getport(&addr);
 325     /* Reuseaddr needed because system inexplicably leaves crud lying around */
 326     code =
 327         setsockopt(AcceptSd, SOL_SOCKET, SO_REUSEADDR, (char *)&on,
 328                    sizeof(on));
 329     if (code)
 330         Log("FSYNC_sync: setsockopt failed with (%d)\n", errno);
 331
 332     for (numTries = 0; numTries < MAX_BIND_TRIES; numTries++) {
 333         if ((code =
 334              bind(AcceptSd, (struct sockaddr *)&addr, sizeof(addr))) == 0)
 335             break;
 336         Log("FSYNC_sync: bind failed with (%d), will sleep and retry\n",
 337             errno);
 338         sleep(5);
 339     }
 340     assert(!code);
 341     listen(AcceptSd, 100);
 342     InitHandler();
 343     AcceptOn();
 344     for (;;) {
 345         int maxfd;
 346         GetHandler(&FSYNC_readfds, &maxfd);
 347         /* Note: check for >= 1 below is essential since IOMGR_select
 348          * doesn't have exactly same semantics as select.
 349          */
 350 #ifdef AFS_PTHREAD_ENV
 351         if (select(maxfd + 1, &FSYNC_readfds, NULL, NULL, NULL) >= 1)
 352 #else /* AFS_PTHREAD_ENV */
 353         if (IOMGR_Select(maxfd + 1, &FSYNC_readfds, NULL, NULL, NULL) >= 1)
 354 #endif /* AFS_PTHREAD_ENV */
 355             CallHandler(&FSYNC_readfds);
 356     }
 357 }
 358
 359 static void
 360 FSYNC_newconnection(int afd)
 361 {
 362     struct sockaddr_in other;
 363     int junk, fd;
 364     junk = sizeof(other);
 365     fd = accept(afd, (struct sockaddr *)&other, &junk);
 366     if (fd == -1) {
 367         Log("FSYNC_newconnection:  accept failed, errno==%d\n", errno);
 368         assert(1 == 2);
 369     } else if (!AddHandler(fd, FSYNC_com)) {
 370         AcceptOff();
 371         assert(AddHandler(fd, FSYNC_com));
 372     }
 373 }
 374
 375 /*
 376 #define TEST2081
 377 */
 378
 379 afs_int32 FS_cnt = 0;
 380 static void
 381 FSYNC_com(int fd)
 382 {
 383     byte rc = FSYNC_OK;
 384     int n, i;
 385     Error error;
 386     struct command command;
 387     int leaveonline;
 388     register struct offlineInfo *volumes, *v;
 389     Volume *vp;
 390     char tvolName[VMAXPATHLEN];
 391
 392     FS_cnt++;
 393 #ifdef AFS_NT40_ENV
 394     n = recv(fd, &command, sizeof(command), 0);
 395 #else
 396     n = read(fd, &command, sizeof(command));
 397 #endif
 398     if (n <= 0) {
 399         FSYNC_Drop(fd);
 400         return;
 401     }
 402     if (n < sizeof(command)) {
 403         Log("FSYNC_com:  partial read (%d instead of %d); dropping connection (cnt=%d)\n", n, sizeof(command), FS_cnt);
 404         FSYNC_Drop(fd);
 405         return;
 406     }
 407     VATTACH_LOCK VOL_LOCK volumes = OfflineVolumes[FindHandler(fd)];
 408     for (v = 0, i = 0; i < MAXOFFLINEVOLUMES; i++) {
 409         if (volumes[i].volumeID == command.volume
 410             && strcmp(volumes[i].partName, command.partName) == 0) {
 411             v = &volumes[i];
 412             break;
 413         }
 414     }
 415     switch (command.command) {
 416     case FSYNC_DONE:
 417         /* don't try to put online, this call is made only after deleting
 418          * a volume, in which case we want to remove the vol # from the
 419          * OfflineVolumes array only */
 420         if (v)
 421             v->volumeID = 0;
 422         break;
 423     case FSYNC_ON:
 424
 425 /*
 426 This is where a detatched volume gets reattached. However in the
 427 special case where the volume is merely busy, it is already
 428 attatched and it is only necessary to clear the busy flag. See
 429 defect #2080 for details.
 430 */
 431
 432         /* is the volume already attatched? */
 433 #ifdef  notdef
 434 /*
 435  * XXX With the following enabled we had bizarre problems where the backup id would
 436  * be reset to 0; that was due to the interaction between fileserver/volserver in that they
 437  * both keep volumes in memory and the changes wouldn't be made to the fileserver. Some of
 438  * the problems were due to refcnt changes as result of VGetVolume/VPutVolume which would call
 439  * VOffline, etc. when we don't want to; someday the whole #2080 issue should be revisited to
 440  * be done right XXX
 441  */
 442         vp = VGetVolume_r(&error, command.volume);
 443         if (vp) {
 444             /* yep, is the BUSY flag set? */
 445             if (vp->specialStatus == VBUSY) {
 446 /* test harness for defect #2081 */
 447
 448 #ifdef TEST2081
 449                 /*
 450                  * test #2081 by releasing TEST.2081,
 451                  * so leave it alone here, zap it after
 452                  */
 453
 454                 if (strcmp(vp->header->diskstuff.name, "TEST.2081") == 0)
 455                     break;
 456 #endif
 457                 /* yep, clear BUSY flag */
 458
 459                 vp->specialStatus = 0;
 460                 /* make sure vol is online */
 461                 if (v) {
 462                     v->volumeID = 0;
 463                     V_inUse(vp) = 1;    /* online */
 464                 }
 465                 VPutVolume_r(vp);
 466                 break;
 467             }
 468             VPutVolume_r(vp);
 469         }
 470 #endif
 471
 472         /* so, we need to attach the volume */
 473
 474         if (v)
 475             v->volumeID = 0;
 476         tvolName[0] = '/';
 477         sprintf(&tvolName[1], VFORMAT, command.volume);
 478
 479         vp = VAttachVolumeByName_r(&error, command.partName, tvolName,
 480                                    V_VOLUPD);
 481         if (vp)
 482             VPutVolume_r(vp);
 483         break;
 484     case FSYNC_OFF:
 485     case FSYNC_NEEDVOLUME:{
 486             leaveonline = 0;
 487             /* not already offline, we need to find a slot for newly offline volume */
 488             if (!v) {
 489                 for (i = 0; i < MAXOFFLINEVOLUMES; i++) {
 490                     if (volumes[i].volumeID == 0) {
 491                         v = &volumes[i];
 492                         break;
 493                     }
 494                 }
 495             }
 496             if (!v) {
 497                 rc = FSYNC_DENIED;
 498                 break;
 499             }
 500             vp = VGetVolume_r(&error, command.volume);
 501             if (vp) {
 502                 if (command.partName[0] != 0
 503                     && strcmp(command.partName, vp->partition->name) != 0) {
 504                     /* volume on desired partition is not online, so we
 505                      * should treat this as an offline volume.
 506                      */
 507                     VPutVolume_r(vp);
 508                     vp = (Volume *) 0;
 509                 }
 510             }
 511             if (vp) {
 512                 leaveonline = (command.command == FSYNC_NEEDVOLUME
 513                                && (command.reason == V_READONLY
 514                                    || (!VolumeWriteable(vp)
 515                                        && (command.reason == V_CLONE
 516                                            || command.reason == V_DUMP))
 517                                )
 518                     );
 519                 if (!leaveonline) {
 520                     if (command.command == FSYNC_NEEDVOLUME
 521                         && (command.reason == V_CLONE
 522                             || command.reason == V_DUMP)) {
 523                         vp->specialStatus = VBUSY;
 524                     }
 525                     /* remember what volume we got, so we can keep track of how
 526                      * many volumes the volserver or whatever is using.  Note that
 527                      * vp is valid since leaveonline is only set when vp is valid.
 528                      */
 529                     v->volumeID = command.volume;
 530                     strcpy(v->partName, vp->partition->name);
 531                     if (!V_inUse(vp)) {
 532                         /* in this case, VOffline just returns sans decrementing
 533                          * ref count.  We could try to fix it, but it has lots of
 534                          * weird callers.
 535                          */
 536                         VPutVolume_r(vp);
 537                     } else {
 538                         VOffline_r(vp, "A volume utility is running.");
 539                     }
 540                     vp = 0;
 541                 } else {
 542                     VUpdateVolume_r(&error, vp);        /* At least get volume stats right */
 543                     if (LogLevel) {
 544                         Log("FSYNC: Volume %u (%s) was left on line for an external %s request\n", V_id(vp), V_name(vp), command.reason == V_CLONE ? "clone" : command.reason == V_READONLY ? "readonly" : command.reason == V_DUMP ? "dump" : "UNKNOWN");
 545                     }
 546                 }
 547                 if (vp)
 548                     VPutVolume_r(vp);
 549             }
 550             rc = FSYNC_OK;
 551             break;
 552         }
 553     case FSYNC_MOVEVOLUME:
 554         /* Yuch:  the "reason" for the move is the site it got moved to... */
 555         /* still set specialStatus so we stop sending back VBUSY.
 556          * also should still break callbacks.  Note that I don't know
 557          * how to tell if we should break all or not, so we just do it
 558          * since it doesn't matter much if we do an extra break
 559          * volume callbacks on a volume move within the same server */
 560         vp = VGetVolume_r(&error, command.volume);
 561         if (vp) {
 562             vp->specialStatus = VMOVED;
 563             VPutVolume_r(vp);
 564         }
 565
 566         if (V_BreakVolumeCallbacks) {
 567             Log("fssync: volume %u moved to %x; breaking all call backs\n",
 568                 command.volume, command.reason);
 569             VOL_UNLOCK VATTACH_UNLOCK(*V_BreakVolumeCallbacks) (command.
 570                                                                 volume);
 571         VATTACH_LOCK VOL_LOCK}
 572         break;
 573     case FSYNC_RESTOREVOLUME:
 574         /* if the volume is being restored, break all callbacks on it */
 575         if (V_BreakVolumeCallbacks) {
 576             Log("fssync: volume %u restored; breaking all call backs\n",
 577                 command.volume);
 578             VOL_UNLOCK VATTACH_UNLOCK(*V_BreakVolumeCallbacks) (command.
 579                                                                 volume);
 580         VATTACH_LOCK VOL_LOCK}
 581         break;
 582     default:
 583         rc = FSYNC_DENIED;
 584         break;
 585     }
 586     VOL_UNLOCK VATTACH_UNLOCK
 587 #ifdef AFS_NT40_ENV
 588       (void) send(fd, &rc, 1, 0);
 589 #else
 590       (void) write(fd, &rc, 1);
 591 #endif
 592 }
 593
 594 static void
 595 FSYNC_Drop(int fd)
 596 {
 597     struct offlineInfo *p;
 598     register i;
 599     Error error;
 600     char tvolName[VMAXPATHLEN];
 601
 602     VATTACH_LOCK VOL_LOCK p = OfflineVolumes[FindHandler(fd)];
 603     for (i = 0; i < MAXOFFLINEVOLUMES; i++) {
 604         if (p[i].volumeID) {
 605             Volume *vp;
 606
 607             tvolName[0] = '/';
 608             sprintf(&tvolName[1], VFORMAT, p[i].volumeID);
 609             vp = VAttachVolumeByName_r(&error, p[i].partName, tvolName,
 610                                        V_VOLUPD);
 611             if (vp)
 612                 VPutVolume_r(vp);
 613             p[i].volumeID = 0;
 614         }
 615     }
 616     VOL_UNLOCK VATTACH_UNLOCK RemoveHandler(fd);
 617 #ifdef AFS_NT40_ENV
 618     closesocket(fd);
 619 #else
 620     close(fd);
 621 #endif
 622     AcceptOn();
 623 }
 624
 625 static int AcceptHandler = -1;  /* handler id for accept, if turned on */
 626
 627 static void
 628 AcceptOn()
 629 {
 630     if (AcceptHandler == -1) {
 631         assert(AddHandler(AcceptSd, FSYNC_newconnection));
 632         AcceptHandler = FindHandler(AcceptSd);
 633     }
 634 }
 635
 636 static void
 637 AcceptOff()
 638 {
 639     if (AcceptHandler != -1) {
 640         assert(RemoveHandler(AcceptSd));
 641         AcceptHandler = -1;
 642     }
 643 }
 644
 645 /* The multiple FD handling code. */
 646
 647 static int HandlerFD[MAXHANDLERS];
 648 static int (*HandlerProc[MAXHANDLERS]) ();
 649
 650 static void
 651 InitHandler()
 652 {
 653     register int i;
 654     ObtainWriteLock(&FSYNC_handler_lock);
 655     for (i = 0; i < MAXHANDLERS; i++) {
 656         HandlerFD[i] = -1;
 657         HandlerProc[i] = 0;
 658     }
 659     ReleaseWriteLock(&FSYNC_handler_lock);
 660 }
 661
 662 static void
 663 CallHandler(fd_set * fdsetp)
 664 {
 665     register int i;
 666     ObtainReadLock(&FSYNC_handler_lock);
 667     for (i = 0; i < MAXHANDLERS; i++) {
 668         if (HandlerFD[i] >= 0 && FD_ISSET(HandlerFD[i], fdsetp)) {
 669             ReleaseReadLock(&FSYNC_handler_lock);
 670             (*HandlerProc[i]) (HandlerFD[i]);
 671             ObtainReadLock(&FSYNC_handler_lock);
 672         }
 673     }
 674     ReleaseReadLock(&FSYNC_handler_lock);
 675 }
 676
 677 static int
 678 AddHandler(int afd, int (*aproc) ())
 679 {
 680     register int i;
 681     ObtainWriteLock(&FSYNC_handler_lock);
 682     for (i = 0; i < MAXHANDLERS; i++)
 683         if (HandlerFD[i] == -1)
 684             break;
 685     if (i >= MAXHANDLERS) {
 686         ReleaseWriteLock(&FSYNC_handler_lock);
 687         return 0;
 688     }
 689     HandlerFD[i] = afd;
 690     HandlerProc[i] = aproc;
 691     ReleaseWriteLock(&FSYNC_handler_lock);
 692     return 1;
 693 }
 694
 695 static int
 696 FindHandler(register int afd)
 697 {
 698     register int i;
 699     ObtainReadLock(&FSYNC_handler_lock);
 700     for (i = 0; i < MAXHANDLERS; i++)
 701         if (HandlerFD[i] == afd) {
 702             ReleaseReadLock(&FSYNC_handler_lock);
 703             return i;
 704         }
 705     ReleaseReadLock(&FSYNC_handler_lock);       /* just in case */
 706     assert(1 == 2);
 707     return -1;                  /* satisfy compiler */
 708 }
 709
 710 static int
 711 FindHandler_r(register int afd)
 712 {
 713     register int i;
 714     for (i = 0; i < MAXHANDLERS; i++)
 715         if (HandlerFD[i] == afd) {
 716             return i;
 717         }
 718     assert(1 == 2);
 719     return -1;                  /* satisfy compiler */
 720 }
 721
 722 static int
 723 RemoveHandler(register int afd)
 724 {
 725     ObtainWriteLock(&FSYNC_handler_lock);
 726     HandlerFD[FindHandler_r(afd)] = -1;
 727     ReleaseWriteLock(&FSYNC_handler_lock);
 728     return 1;
 729 }
 730
 731 static void
 732 GetHandler(fd_set * fdsetp, int *maxfdp)
 733 {
 734     register int i;
 735     register int maxfd = -1;
 736     FD_ZERO(fdsetp);
 737     ObtainReadLock(&FSYNC_handler_lock);        /* just in case */
 738     for (i = 0; i < MAXHANDLERS; i++)
 739         if (HandlerFD[i] != -1) {
 740             FD_SET(HandlerFD[i], fdsetp);
 741             if (maxfd < HandlerFD[i])
 742                 maxfd = HandlerFD[i];
 743         }
 744     *maxfdp = maxfd;
 745     ReleaseReadLock(&FSYNC_handler_lock);       /* just in case */
 746 }