src/afs/afs_server.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  * Implements:
  12  * afs_MarkServerUpOrDown
  13  * afs_ServerDown
  14  * afs_CountServers
  15  * afs_CheckServers
  16  * afs_FindServer
  17  * afs_random
  18  * afs_randomMod127
  19  * afs_SortServers
  20  * afsi_SetServerIPRank
  21  * afs_GetServer
  22  * afs_ActivateServer
  23  *
  24  *
  25  * Local:
  26  * HaveCallBacksFrom
  27  * CheckVLServer
  28  * afs_SortOneServer
  29  * afs_SetServerPrefs
  30  *
  31  */
  32 #include <afsconfig.h>
  33 #include "../afs/param.h"
  34
  35 RCSID("$Header$");
  36
  37 #include "../afs/stds.h"
  38 #include "../afs/sysincludes.h" /* Standard vendor system headers */
  39
  40 #if !defined(UKERNEL)
  41 #include <net/if.h>
  42 #include <netinet/in.h>
  43
  44 #ifdef AFS_SGI62_ENV
  45 #include "../h/hashing.h"
  46 #endif
  47 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV)
  48 #include <netinet/in_var.h>
  49 #endif /* AFS_HPUX110_ENV */
  50 #endif /* !defined(UKERNEL) */
  51
  52 #include "../afs/afsincludes.h" /* Afs-based standard headers */
  53 #include "../afs/afs_stats.h"   /* afs statistics */
  54
  55 #if     defined(AFS_SUN56_ENV)
  56 #include <inet/led.h>
  57 #include <inet/common.h>
  58 #if     defined(AFS_SUN58_ENV)
  59 # include <netinet/ip6.h>
  60 # define ipif_local_addr ipif_lcl_addr
  61 #  ifndef V4_PART_OF_V6
  62 #  define V4_PART_OF_V6(v6)       v6.s6_addr32[3]
  63 #  endif
  64 # endif
  65 #include <inet/ip.h>
  66 #endif
  67
  68 /* Imported variables */
  69 extern afs_int32 afs_setTime;
  70 extern afs_int32 afs_waitForever;
  71 extern short afs_waitForeverCount;
  72
  73
  74 /* Exported variables */
  75 afs_rwlock_t afs_xserver;               /* allocation lock for servers */
  76 struct server *afs_setTimeHost=0;       /* last host we used for time */
  77 struct server *afs_servers[NSERVERS];    /* Hashed by server`s uuid & 1st ip */
  78 afs_rwlock_t afs_xsrvAddr;              /* allocation lock for srvAddrs */
  79 struct srvAddr *afs_srvAddrs[NSERVERS];  /* Hashed by server's ip */
  80
  81
  82 /* debugging aids - number of alloc'd server and srvAddr structs. */
  83 int afs_reuseServers  = 0;
  84 int afs_reuseSrvAddrs = 0;
  85 int afs_totalServers  = 0;
  86 int afs_totalSrvAddrs = 0;
  87
  88
  89
  90
  91 /*------------------------------------------------------------------------
  92  * afs_MarkServerUpOrDown
  93  *
  94  * Description:
  95  *      Mark the given server up or down, and track its uptime stats.
  96  *
  97  * Arguments:
  98  *      a_serverP : Ptr to server record to fiddle with.
  99  *      a_isDown  : Is the server is to be marked down?
 100  *
 101  * Returns:
 102  *      Nothing.
 103  *
 104  * Environment:
 105  *      The CM server structures must be write-locked.
 106  *
 107  * Side Effects:
 108  *      As advertised.
 109  *------------------------------------------------------------------------*/
 110
 111 void afs_MarkServerUpOrDown(struct srvAddr *sa, int a_isDown)
 112 {
 113     register struct server *a_serverP = sa->server;
 114     register struct srvAddr *sap;
 115     osi_timeval_t currTime, *currTimeP;     /*Current time*/
 116     afs_int32 downTime;                      /*Computed downtime, in seconds*/
 117     struct afs_stats_SrvUpDownInfo *upDownP; /*Ptr to up/down info record*/
 118
 119     /*
 120      * If the server record is marked the same as the new status we've
 121      * been fed, then there isn't much to be done.
 122      */
 123     if (( a_isDown &&  (sa->sa_flags & SRVADDR_ISDOWN)) ||
 124         (!a_isDown && !(sa->sa_flags & SRVADDR_ISDOWN)))
 125         return;
 126
 127     if (a_isDown) {
 128         sa->sa_flags |= SRVADDR_ISDOWN;
 129         for (sap = a_serverP->addr; sap; sap = sap->next_sa) {
 130             if (!(sap->sa_flags & SRVADDR_ISDOWN)) {
 131                 /* Not all ips are up so don't bother with the
 132                  * server's up/down stats */
 133                 return;
 134             }
 135         }
 136         /*
 137          * All ips are down we treat the whole server down
 138          */
 139         a_serverP->flags |= SRVR_ISDOWN;
 140         /*
 141          * If this was our time server, search for another time server
 142          */
 143         if (a_serverP == afs_setTimeHost)
 144             afs_setTimeHost = 0;
 145     } else {
 146         sa->sa_flags &= ~SRVADDR_ISDOWN;
 147         /* If any ips are up, the server is also marked up */
 148         a_serverP->flags &= ~SRVR_ISDOWN;
 149         for (sap = a_serverP->addr; sap; sap = sap->next_sa) {
 150             if (sap->sa_flags & SRVADDR_ISDOWN) {
 151                 /* Not all ips are up so don't bother with the
 152                  * server's up/down stats */
 153                 return;
 154             }
 155         }
 156     }
 157 #ifndef AFS_NOSTATS
 158     /*
 159      * Compute the current time and which overall stats record is to be
 160      * updated; we'll need them one way or another.
 161      */
 162     currTimeP = &currTime;
 163     osi_GetuTime(currTimeP);
 164
 165     if (sa->sa_portal == AFS_FSPORT) {
 166         upDownP = (a_serverP->cell->cell == 1) ?
 167             &(afs_stats_cmperf.fs_UpDown[AFS_STATS_UPDOWN_IDX_SAME_CELL]) :
 168             &(afs_stats_cmperf.fs_UpDown[AFS_STATS_UPDOWN_IDX_DIFF_CELL]);
 169     } /*File Server record*/
 170     else {
 171         upDownP = (a_serverP->cell->cell == 1) ?
 172             &(afs_stats_cmperf.vl_UpDown[AFS_STATS_UPDOWN_IDX_SAME_CELL]) :
 173             &(afs_stats_cmperf.vl_UpDown[AFS_STATS_UPDOWN_IDX_DIFF_CELL]);
 174     } /*VL Server record*/
 175
 176     if (a_isDown) {
 177         /*
 178          * Server going up -> down; remember the beginning of this
 179          * downtime incident.
 180          */
 181         a_serverP->lastDowntimeStart = currTime.tv_sec;
 182
 183         (upDownP->numDownRecords)++;
 184         (upDownP->numUpRecords)--;
 185     } /*Server being marked down*/
 186     else {
 187         /*
 188          * Server going down -> up; remember everything about this
 189          * newly-completed downtime incident.
 190          */
 191         downTime = currTime.tv_sec - a_serverP->lastDowntimeStart;
 192         (a_serverP->numDowntimeIncidents)++;
 193         a_serverP->sumOfDowntimes += downTime;
 194
 195         (upDownP->numUpRecords)++;
 196         (upDownP->numDownRecords)--;
 197         (upDownP->numDowntimeIncidents)++;
 198         if (a_serverP->numDowntimeIncidents == 1)
 199             (upDownP->numRecordsNeverDown)--;
 200         upDownP->sumOfDowntimes += downTime;
 201         if ((upDownP->shortestDowntime == 0) ||
 202             (downTime < upDownP->shortestDowntime))
 203             upDownP->shortestDowntime = downTime;
 204         if ((upDownP->longestDowntime == 0) ||
 205             (downTime > upDownP->longestDowntime))
 206             upDownP->longestDowntime = downTime;
 207
 208
 209         if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET0)
 210             (upDownP->downDurations[0])++;
 211         else
 212             if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET1)
 213                 (upDownP->downDurations[1])++;
 214         else
 215             if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET2)
 216                 (upDownP->downDurations[2])++;
 217         else
 218             if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET3)
 219                 (upDownP->downDurations[3])++;
 220         else
 221             if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET4)
 222                 (upDownP->downDurations[4])++;
 223         else
 224             if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET5)
 225                 (upDownP->downDurations[5])++;
 226         else
 227             (upDownP->downDurations[6])++;
 228
 229     } /*Server being marked up*/
 230 #endif
 231 } /*MarkServerUpOrDown*/
 232
 233
 234 void afs_ServerDown(struct srvAddr *sa)
 235 {
 236     register struct server *aserver = sa->server;
 237     register struct srvAddr *sap;
 238
 239     AFS_STATCNT(ServerDown);
 240     if (aserver->flags & SRVR_ISDOWN || sa->sa_flags & SRVADDR_ISDOWN)
 241         return;
 242     afs_MarkServerUpOrDown(sa, SRVR_ISDOWN);
 243     if (sa->sa_portal == aserver->cell->vlport)
 244          print_internet_address("afs: Lost contact with volume location server ",
 245                                sa, "", 1);
 246     else
 247          print_internet_address("afs: Lost contact with file server ", sa, "", 1);
 248
 249 } /*ServerDown*/
 250
 251
 252 /* return true if we have any callback promises from this server */
 253 static HaveCallBacksFrom(aserver)
 254     struct server *aserver;
 255
 256 {
 257     register afs_int32 now;
 258     register int i;
 259     register struct vcache *tvc;
 260
 261     AFS_STATCNT(HaveCallBacksFrom);
 262     now = osi_Time();       /* for checking for expired callbacks */
 263     for(i=0;i<VCSIZE;i++) { /* for all guys in the hash table */
 264         for(tvc = afs_vhashT[i]; tvc; tvc=tvc->hnext) {
 265             /*
 266              * Check to see if this entry has an unexpired callback promise
 267              * from the required host
 268              */
 269             if (aserver == tvc->callback && tvc->cbExpires >= now
 270                 && ((tvc->states & CRO) == 0))
 271                 return 1;
 272         }
 273     }
 274     return 0;
 275
 276 } /*HaveCallBacksFrom*/
 277
 278
 279 static void CheckVLServer(sa, areq)
 280     struct vrequest *areq;
 281     register struct srvAddr *sa;
 282 {
 283     register struct server *aserver = sa->server;
 284     register struct conn *tc;
 285     register afs_int32 code;
 286
 287     AFS_STATCNT(CheckVLServer);
 288     /* Ping dead servers to see if they're back */
 289     if (!((aserver->flags & SRVR_ISDOWN) || (sa->sa_flags & SRVADDR_ISDOWN)) || (aserver->flags & SRVR_ISGONE))
 290         return;
 291     if (!aserver->cell)
 292         return; /* can't do much */
 293
 294     tc = afs_ConnByHost(aserver, aserver->cell->vlport,
 295                         aserver->cell->cell, areq, 1, SHARED_LOCK);
 296     if (!tc)
 297         return;
 298     rx_SetConnDeadTime(tc->id, 3);
 299
 300 #ifdef RX_ENABLE_LOCKS
 301     AFS_GUNLOCK();
 302 #endif /* RX_ENABLE_LOCKS */
 303     code = VL_ProbeServer(tc->id);
 304 #ifdef RX_ENABLE_LOCKS
 305     AFS_GLOCK();
 306 #endif /* RX_ENABLE_LOCKS */
 307     rx_SetConnDeadTime(tc->id, 50);
 308     afs_PutConn(tc, SHARED_LOCK);
 309     /*
 310      * If probe worked, or probe call not yet defined (for compatibility
 311      * with old vlsevers), then we treat this server as running again
 312      */
 313     if (code == 0 || (code <= -450 && code >= -470)) {
 314         if (tc->srvr == sa) {
 315             afs_MarkServerUpOrDown(sa, 0);
 316             print_internet_address("afs: volume location server ",
 317                                    sa, " is back up", 2);
 318         }
 319     }
 320
 321 } /*CheckVLServer*/
 322
 323
 324 #ifndef AFS_MINCHANGE   /* So that some can increase it in param.h */
 325 #define AFS_MINCHANGE 2         /* min change we'll bother with */
 326 #endif
 327 #ifndef AFS_MAXCHANGEBACK
 328 #define AFS_MAXCHANGEBACK 10    /* max seconds we'll set a clock back at once */
 329 #endif
 330
 331
 332 /*------------------------------------------------------------------------
 333  * EXPORTED afs_CountServers
 334  *
 335  * Description:
 336  *      Originally meant to count the number of servers and determining
 337  *      up/down info, this routine will now simply sum up all of the
 338  *      server record ages.  All other up/down information is kept on the
 339  *      fly.
 340  *
 341  * Arguments:
 342  *      None.
 343  *
 344  * Returns:
 345  *      Nothing.
 346  *
 347  * Environment:
 348  *      This routine locks afs_xserver for write for the duration.
 349  *
 350  * Side Effects:
 351  *      Set CM perf stats field sumOfRecordAges for all server record
 352  *      entries.
 353  *------------------------------------------------------------------------*/
 354
 355 void afs_CountServers()
 356
 357 { /*afs_CountServers*/
 358
 359     int currIdx;                                /*Curr idx into srv table*/
 360     struct server *currSrvP;                    /*Ptr to curr server record*/
 361     afs_int32 currChainLen;                             /*Length of curr hash chain*/
 362     osi_timeval_t currTime;                     /*Current time*/
 363     osi_timeval_t *currTimeP;                   /*Ptr to above*/
 364     afs_int32 srvRecordAge;                             /*Age of server record, in secs*/
 365     struct afs_stats_SrvUpDownInfo *upDownP;    /*Ptr to current up/down
 366                                                   info being manipulated*/
 367
 368     /*
 369      * Write-lock the server table so we don't get any interference.
 370      */
 371     ObtainReadLock(&afs_xserver);
 372
 373     /*
 374      * Iterate over each hash index in the server table, walking down each
 375      * chain and tallying what we haven't computed from the records there on
 376      * the fly.  First, though, initialize the tallies that will change.
 377      */
 378     afs_stats_cmperf.srvMaxChainLength = 0;
 379
 380     afs_stats_cmperf.fs_UpDown[0].sumOfRecordAges     = 0;
 381     afs_stats_cmperf.fs_UpDown[0].ageOfYoungestRecord = 0;
 382     afs_stats_cmperf.fs_UpDown[0].ageOfOldestRecord   = 0;
 383     memset((char *) afs_stats_cmperf.fs_UpDown[0].downIncidents, 0, AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
 384
 385     afs_stats_cmperf.fs_UpDown[1].sumOfRecordAges     = 0;
 386     afs_stats_cmperf.fs_UpDown[1].ageOfYoungestRecord = 0;
 387     afs_stats_cmperf.fs_UpDown[1].ageOfOldestRecord   = 0;
 388     memset((char *) afs_stats_cmperf.fs_UpDown[1].downIncidents, 0, AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
 389
 390     afs_stats_cmperf.vl_UpDown[0].sumOfRecordAges     = 0;
 391     afs_stats_cmperf.vl_UpDown[0].ageOfYoungestRecord = 0;
 392     afs_stats_cmperf.vl_UpDown[0].ageOfOldestRecord   = 0;
 393     memset((char *) afs_stats_cmperf.vl_UpDown[0].downIncidents, 0, AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
 394
 395     afs_stats_cmperf.vl_UpDown[1].sumOfRecordAges     = 0;
 396     afs_stats_cmperf.vl_UpDown[1].ageOfYoungestRecord = 0;
 397     afs_stats_cmperf.vl_UpDown[1].ageOfOldestRecord   = 0;
 398     memset((char *) afs_stats_cmperf.vl_UpDown[1].downIncidents, 0, AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
 399
 400     /*
 401      * Compute the current time, used to figure out server record ages.
 402      */
 403     currTimeP = &currTime;
 404     osi_GetuTime(currTimeP);
 405
 406     /*
 407      * Sweep the server hash table, tallying all we need to know.
 408      */
 409     for (currIdx = 0; currIdx < NSERVERS; currIdx++) {
 410         currChainLen = 0;
 411         for (currSrvP = afs_servers[currIdx]; currSrvP; currSrvP = currSrvP->next) {
 412             /*
 413              * Bump the current chain length.
 414              */
 415             currChainLen++;
 416
 417             /*
 418              * Any further tallying for this record will only be done if it has
 419              * been activated.
 420              */
 421             if ( (currSrvP->flags & AFS_SERVER_FLAG_ACTIVATED) &&
 422                   currSrvP->addr && currSrvP->cell ) {
 423
 424                 /*
 425                  * Compute the current server record's age, then remember it
 426                  * in the appropriate places.
 427                  */
 428                 srvRecordAge = currTime.tv_sec - currSrvP->activationTime;
 429                 if (currSrvP->addr->sa_portal == AFS_FSPORT) {
 430                     upDownP = (currSrvP->cell->cell == 1) ?
 431                         &(afs_stats_cmperf.fs_UpDown[AFS_STATS_UPDOWN_IDX_SAME_CELL]):
 432                         &(afs_stats_cmperf.fs_UpDown[AFS_STATS_UPDOWN_IDX_DIFF_CELL]);
 433                 } /*File Server record*/
 434                 else {
 435                     upDownP = (currSrvP->cell->cell == 1) ?
 436                         &(afs_stats_cmperf.vl_UpDown[AFS_STATS_UPDOWN_IDX_SAME_CELL]):
 437                         &(afs_stats_cmperf.vl_UpDown[AFS_STATS_UPDOWN_IDX_DIFF_CELL]);
 438                 } /*VL Server record*/
 439
 440                 upDownP->sumOfRecordAges += srvRecordAge;
 441                 if ((upDownP->ageOfYoungestRecord == 0) ||
 442                     (srvRecordAge < upDownP->ageOfYoungestRecord))
 443                     upDownP->ageOfYoungestRecord = srvRecordAge;
 444                 if ((upDownP->ageOfOldestRecord == 0) ||
 445                     (srvRecordAge > upDownP->ageOfOldestRecord))
 446                     upDownP->ageOfOldestRecord = srvRecordAge;
 447
 448                 if (currSrvP->numDowntimeIncidents <=
 449                     AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET0)
 450                     (upDownP->downIncidents[0])++;
 451                 else
 452                     if (currSrvP->numDowntimeIncidents <=
 453                         AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET1)
 454                         (upDownP->downIncidents[1])++;
 455                 else
 456                     if (currSrvP->numDowntimeIncidents <=
 457                         AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET2)
 458                         (upDownP->downIncidents[2])++;
 459                 else
 460                     if (currSrvP->numDowntimeIncidents <=
 461                         AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET3)
 462                         (upDownP->downIncidents[3])++;
 463                 else
 464                     if (currSrvP->numDowntimeIncidents <=
 465                         AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET4)
 466                         (upDownP->downIncidents[4])++;
 467                 else
 468                     (upDownP->downIncidents[5])++;
 469
 470
 471             } /*Current server has been active*/
 472         } /*Walk this chain*/
 473
 474         /*
 475          * Before advancing to the next chain, remember facts about this one.
 476          */
 477         if (currChainLen > afs_stats_cmperf.srvMaxChainLength) {
 478             /*
 479              * We beat out the former champion (which was initially set to 0
 480              * here).  Mark down the new winner, and also remember if it's an
 481              * all-time winner.
 482              */
 483             afs_stats_cmperf.srvMaxChainLength = currChainLen;
 484             if (currChainLen > afs_stats_cmperf.srvMaxChainLengthHWM)
 485                 afs_stats_cmperf.srvMaxChainLengthHWM = currChainLen;
 486         } /*Update chain length maximum*/
 487     } /*For each hash chain*/
 488
 489     /*
 490      * We're done.  Unlock the server table before returning to our caller.
 491      */
 492     ReleaseReadLock(&afs_xserver);
 493
 494 } /*afs_CountServers*/
 495
 496
 497 /* check down servers (if adown), or running servers (if !adown) */
 498 void afs_CheckServers(adown, acellp)
 499     struct cell *acellp;
 500     int adown;
 501
 502 {
 503     struct vrequest treq;
 504     struct server *ts;
 505     struct srvAddr *sa;
 506     struct conn *tc;
 507     afs_int32 i;
 508     afs_int32 code;
 509     afs_int32 start, end, delta;
 510     osi_timeval_t tv;
 511     int setTimer;
 512     struct unixuser *tu;
 513     char tbuffer[CVBS];
 514     XSTATS_DECLS;
 515
 516     AFS_STATCNT(afs_CheckServers);
 517     if (code = afs_InitReq(&treq, &afs_osi_cred)) return;
 518     ObtainReadLock(&afs_xserver);  /* Necessary? */
 519     ObtainReadLock(&afs_xsrvAddr);
 520
 521     for (i=0;i<NSERVERS;i++) {
 522        for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
 523           ts = sa->server;
 524           if (!ts)
 525              continue;
 526           /* See if a cell to check was specified.  If it is spec'd and not
 527            * this server's cell, just skip the server.
 528            */
 529           if (acellp && acellp != ts->cell)
 530                continue;
 531
 532           if ((!adown && (sa->sa_flags & SRVADDR_ISDOWN))
 533               || (adown && !(sa->sa_flags & SRVADDR_ISDOWN)))
 534                continue;
 535           /* check vlserver with special code */
 536           if (sa->sa_portal == AFS_VLPORT) {
 537              CheckVLServer(sa, &treq);
 538              continue;
 539           }
 540
 541           if (!ts->cell) /* not really an active server, anyway, it must */
 542              continue;   /* have just been added by setsprefs */
 543
 544           /* get a connection, even if host is down; bumps conn ref count */
 545           tu = afs_GetUser(treq.uid, ts->cell, SHARED_LOCK);
 546           tc = afs_ConnBySA(sa, ts->cell->fsport, ts->cell->cell, tu,
 547                             1/*force*/, 1/*create*/, SHARED_LOCK);
 548           afs_PutUser(tu, SHARED_LOCK);
 549           if (!tc)
 550                continue;
 551
 552           if ((sa->sa_flags & SRVADDR_ISDOWN) || HaveCallBacksFrom(ts) ||
 553               (tc->srvr->server == afs_setTimeHost)) {
 554              if (sa->sa_flags & SRVADDR_ISDOWN) {
 555                 rx_SetConnDeadTime(tc->id, 3);
 556                 setTimer = 1;
 557              } else
 558                   setTimer = 0;
 559              XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_GETTIME);
 560              start = osi_Time();        /* time the gettimeofday call */
 561 #ifdef RX_ENABLE_LOCKS
 562              AFS_GUNLOCK();
 563 #endif /* RX_ENABLE_LOCKS */
 564              code = RXAFS_GetTime(tc->id, &tv.tv_sec, &tv.tv_usec);
 565 #ifdef RX_ENABLE_LOCKS
 566              AFS_GLOCK();
 567 #endif /* RX_ENABLE_LOCKS */
 568              end = osi_Time();
 569              XSTATS_END_TIME;
 570              /*
 571               * If we're supposed to set the time, and the call worked
 572               * quickly (same second response) and this is the host we
 573               * use for the time and the time is really different, then
 574               * really set the time
 575               */
 576              if (code == 0 && start == end && afs_setTime != 0 &&
 577                  (tc->srvr->server == afs_setTimeHost ||
 578                   /*
 579                    * Sync only to a server in the local cell: cell(id)==1
 580                    * or CPrimary.
 581                    */
 582                   (afs_setTimeHost == (struct server *)0 &&
 583                    (ts->cell->cell == 1 || (ts->cell->states&CPrimary))))) {
 584                 char msgbuf[90];        /* strlen("afs: setting clock...") + slop */
 585                 /* set the time */
 586                 delta = end - tv.tv_sec;   /* how many secs fast we are */
 587                 /* see if clock has changed enough to make it worthwhile */
 588                 if (delta >= AFS_MINCHANGE || delta <= -AFS_MINCHANGE) {
 589                    if (delta > AFS_MAXCHANGEBACK) {
 590                       /* setting clock too far back, just do it a little */
 591                       tv.tv_sec = end - AFS_MAXCHANGEBACK;
 592                    }
 593                    afs_osi_SetTime(&tv);
 594                    if (delta > 0) {
 595                       strcpy(msgbuf, "afs: setting clock back ");
 596                       if (delta > AFS_MAXCHANGEBACK) {
 597                          afs_strcat(msgbuf, afs_cv2string(&tbuffer[CVBS], AFS_MAXCHANGEBACK));
 598                          afs_strcat(msgbuf, " seconds (of ");
 599                          afs_strcat(msgbuf, afs_cv2string(&tbuffer[CVBS], delta - AFS_MAXCHANGEBACK));
 600                          afs_strcat(msgbuf, ", via ");
 601                          print_internet_address(msgbuf, sa, "); clock is still fast.", 0);
 602                       } else {
 603                          afs_strcat(msgbuf, afs_cv2string(&tbuffer[CVBS], delta));
 604                          afs_strcat(msgbuf, " seconds (via ");
 605                          print_internet_address(msgbuf, sa, ").", 0);
 606                       }
 607                    }
 608                    else {
 609                       strcpy(msgbuf, "afs: setting clock ahead ");
 610                       afs_strcat(msgbuf, afs_cv2string(&tbuffer[CVBS], -delta));
 611                       afs_strcat(msgbuf, " seconds (via ");
 612                       print_internet_address(msgbuf, sa, ").", 0);
 613                    }
 614                 }
 615                 afs_setTimeHost = tc->srvr->server;
 616              }
 617              if (setTimer)
 618                   rx_SetConnDeadTime(tc->id, 50);
 619              if (code >= 0 && (sa->sa_flags & SRVADDR_ISDOWN) && (tc->srvr == sa)) {
 620                 /* server back up */
 621                 print_internet_address("afs: file server ", sa, " is back up", 2);
 622                 /*
 623                  * XXX We should hold a server write lock here XXX
 624                  */
 625                 afs_MarkServerUpOrDown(sa, 0);
 626                 if (afs_waitForeverCount) {
 627                    afs_osi_Wakeup(&afs_waitForever);
 628                 }
 629              }
 630              else
 631                   if (code < 0) {
 632                      /* server crashed */
 633                      afs_ServerDown(sa);
 634                      ForceNewConnections(sa);  /* multi homed clients */
 635                   }
 636           }
 637
 638           afs_PutConn(tc, SHARED_LOCK); /* done with it now */
 639        }   /* for each server loop */
 640     }       /* for each server hash bucket loop */
 641     ReleaseReadLock(&afs_xsrvAddr);
 642     ReleaseReadLock(&afs_xserver);
 643
 644 } /*afs_CheckServers*/
 645
 646
 647 /* find a server structure given the host address */
 648 struct server *afs_FindServer (afs_int32 aserver, ushort aport,
 649                                afsUUID *uuidp, afs_int32 locktype)
 650 {
 651     struct server *ts;
 652     struct srvAddr *sa;
 653     int i;
 654
 655     AFS_STATCNT(afs_FindServer);
 656     if (uuidp) {
 657         i = afs_uuid_hash(uuidp) % NSERVERS;
 658         for (ts = afs_servers[i]; ts; ts = ts->next) {
 659             if ( (ts->flags & SRVR_MULTIHOMED) &&
 660                  (memcmp((char *)uuidp, (char *)&ts->sr_uuid, sizeof(*uuidp)) == 0) &&
 661                  (!ts->addr || (ts->addr->sa_portal == aport)) )
 662                 return ts;
 663         }
 664     } else {
 665         i = SHash(aserver);
 666         for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
 667             if ((sa->sa_ip == aserver) && (sa->sa_portal == aport)) {
 668               return sa->server;
 669             }
 670         }
 671     }
 672     return (struct server *)0;
 673
 674 } /*afs_FindServer*/
 675
 676
 677 /* some code for creating new server structs and setting preferences follows
 678  * in the next few lines...
 679  */
 680
 681 #define MAXDEFRANK 60000
 682 #define DEFRANK    40000
 683
 684 /* Random number generator and constants from KnuthV2 2d ed, p170 */
 685
 686 /* Rules:
 687    X = (aX + c) % m
 688    m is a power of two
 689    a % 8 is 5
 690    a is 0.73m  should be 0.01m .. 0.99m
 691    c is more or less immaterial.  1 or a is suggested.
 692
 693 NB:  LOW ORDER BITS are not very random.  To get small random numbers,
 694      treat result as <1, with implied binary point, and multiply by
 695      desired modulus.
 696 NB:  Has to be unsigned, since shifts on signed quantities may preserve
 697      the sign bit.
 698 */
 699 /* added rxi_getaddr() to try to get as much initial randomness as
 700    possible, since at least one customer reboots ALL their clients
 701    simultaneously -- so osi_Time is bound to be the same on some of the
 702    clients.  This is probably OK, but I don't want to see too much of it.
 703 */
 704
 705 #define ranstage(x)     (x)= (afs_uint32) (3141592621U*((afs_uint32)x)+1)
 706 extern afs_int32 rxi_getaddr();
 707
 708 unsigned int afs_random()
 709
 710 {
 711     static afs_int32 state = 0;
 712     register int i;
 713
 714     AFS_STATCNT(afs_random);
 715     if (!state) {
 716         osi_timeval_t t;
 717         osi_GetTime(&t);
 718         /*
 719          * 0xfffffff0 was changed to (~0 << 4) since it works no matter how many
 720          * bits are in a tv_usec
 721          */
 722         state = (t.tv_usec & (~0 << 4) ) + (rxi_getaddr() & 0xff);
 723         state += (t.tv_sec & 0xff);
 724         for (i=0;i<30;i++) {
 725             ranstage(state);
 726         }
 727     }
 728
 729     ranstage(state);
 730     return (state);
 731
 732 } /*afs_random*/
 733
 734 /* returns int 0..14 using the high bits of a pseudo-random number instead of
 735    the low bits, as the low bits are "less random" than the high ones...
 736    slight roundoff error exists, an excercise for the reader.
 737    need to multiply by something with lots of ones in it, so multiply by
 738    8 or 16 is right out.
 739  */
 740 int afs_randomMod15()
 741 {
 742 afs_uint32 temp;
 743
 744 temp = afs_random() >> 4;
 745 temp = (temp *15) >> 28;
 746
 747 return temp;
 748 }
 749
 750 int afs_randomMod127()
 751 {
 752 afs_uint32 temp;
 753
 754 temp = afs_random() >> 7;
 755 temp = (temp *127) >> 25;
 756
 757 return temp;
 758 }
 759
 760 /* afs_SortOneServer()
 761  * Sort all of the srvAddrs, of a server struct, by rank from low to high.
 762  */
 763 void afs_SortOneServer(struct server *asp)
 764 {
 765    struct srvAddr **rootsa, *lowsa, *tsa, *lowprev;
 766    int lowrank, rank;
 767
 768    for (rootsa=&(asp->addr); *rootsa; rootsa=&(lowsa->next_sa)) {
 769       lowprev = (struct srvAddr *)0;
 770       lowsa   = *rootsa;             /* lowest sa is the first one */
 771       lowrank = lowsa->sa_iprank;
 772
 773       for (tsa=*rootsa; tsa->next_sa; tsa=tsa->next_sa) {
 774          rank = tsa->next_sa->sa_iprank;
 775          if (rank < lowrank) {
 776             lowprev = tsa;
 777             lowsa   = tsa->next_sa;
 778             lowrank = lowsa->sa_iprank;
 779          }
 780       }
 781       if (lowprev) { /* found one lower, so rearrange them */
 782          lowprev->next_sa = lowsa->next_sa;
 783          lowsa->next_sa   = *rootsa;
 784          *rootsa          = lowsa;
 785       }
 786    }
 787 }
 788
 789 /* afs_SortServer()
 790  * Sort the pointer to servers by the server's rank (its lowest rank).
 791  * It is assumed that the server already has its IP addrs sorted (the
 792  * first being its lowest rank: afs_GetServer() calls afs_SortOneServer()).
 793  */
 794 void afs_SortServers(struct server *aservers[], int count)
 795 {
 796     struct server *ts;
 797     int i, j, low;
 798
 799     AFS_STATCNT(afs_SortServers);
 800
 801     for (i=0; i<count; i++) {
 802        if (!aservers[i]) break;
 803        for (low=i,j=i+1; j<=count; j++) {
 804           if (!aservers[j]) break;
 805           if (aservers[j]->addr->sa_iprank < aservers[low]->addr->sa_iprank) {
 806              low = j;
 807           }
 808        }
 809        if (low != i) {
 810           ts = aservers[i];
 811           aservers[i] = aservers[low];
 812           aservers[low] = ts;
 813        }
 814     }
 815 } /*afs_SortServers*/
 816
 817 /* afs_SetServerPrefs is rather system-dependent.  It pokes around in kernel
 818    data structures to determine what the local IP addresses and subnet masks
 819    are in order to choose which server(s) are on the local subnet.
 820
 821    As I see it, there are several cases:
 822    1. The server address is one of this host's local addresses.  In this case
 823           this server is to be preferred over all others.
 824    2. The server is on the same subnet as one of the this host's local
 825       addresses.  (ie, an odd-sized subnet, not class A,B,orC)
 826    3. The server is on the same net as this host (class A,B or C)
 827    4. The server is on a different logical subnet or net than this host, but
 828    this host is a 'metric 0 gateway' to it.  Ie, two address-spaces share
 829    one physical medium.
 830    5. This host has a direct (point-to-point, ie, PPP or SLIP) link to the
 831    server.
 832    6. This host and the server are disjoint.
 833
 834    That is a rough order of preference.  If a point-to-point link has a high
 835    metric, I'm assuming that it is a very slow link, and putting it at the
 836    bottom of the list (at least until RX works better over slow links).  If
 837    its metric is 1, I'm assuming that it's relatively fast (T1) and putting
 838    it ahead of #6.
 839    It's not easy to check for case #4, so I'm ignoring it for the time being.
 840
 841    BSD "if" code keeps track of some rough network statistics (cf 'netstat -i')
 842    That could be used to prefer certain servers fairly easily.  Maybe some
 843    other time...
 844
 845    NOTE: this code is very system-dependent, and very dependent on the TCP/IP
 846    protocols (well, addresses that are stored in uint32s, at any rate).
 847  */
 848
 849 #define IA_DST(ia)((struct sockaddr_in *)(&((struct in_ifaddr *)ia)->ia_dstaddr))
 850 #define IA_BROAD(ia)((struct sockaddr_in *)(&((struct in_ifaddr *)ia)->ia_broadaddr))
 851
 852 /* SA2ULONG takes a sockaddr_in, not a sockaddr (same thing, just cast it!) */
 853 #define SA2ULONG(sa) ((sa)->sin_addr.s_addr)
 854 #define TOPR 5000
 855 #define HI  20000
 856 #define MED 30000
 857 #define LO DEFRANK
 858 #define PPWEIGHT 4096
 859
 860 #define USEIFADDR
 861
 862
 863 #if     defined(AFS_SUN5_ENV) && ! defined(AFS_SUN56_ENV)
 864 #include <inet/common.h>
 865 /* IP interface structure, one per local address */
 866 typedef struct ipif_s {                 /**/
 867         struct ipif_s   * ipif_next;
 868         struct ill_s    * ipif_ill;     /* Back pointer to our ill */
 869         long    ipif_id;                /* Logical unit number */
 870         u_int   ipif_mtu;               /* Starts at ipif_ill->ill_max_frag */
 871         afs_int32       ipif_local_addr;        /* Local IP address for this if. */
 872         afs_int32       ipif_net_mask;          /* Net mask for this interface. */
 873         afs_int32       ipif_broadcast_addr;    /* Broadcast addr for this interface. */
 874         afs_int32       ipif_pp_dst_addr;       /* Point-to-point dest address. */
 875         u_int   ipif_flags;             /* Interface flags. */
 876         u_int   ipif_metric;            /* BSD if metric, for compatibility. */
 877         u_int   ipif_ire_type;          /* LOCAL or LOOPBACK */
 878         mblk_t  * ipif_arp_down_mp;     /* Allocated at time arp comes up to
 879                                          * prevent awkward out of mem condition
 880                                          * later
 881                                          */
 882         mblk_t  * ipif_saved_ire_mp;    /* Allocated for each extra IRE_SUBNET/
 883                                          * RESOLVER on this interface so that
 884                                          * they can survive ifconfig down.
 885                                          */
 886         /*
 887          * The packet counts in the ipif contain the sum of the
 888          * packet counts in dead IREs that were affiliated with
 889          * this ipif.
 890          */
 891         u_long  ipif_fo_pkt_count;      /* Forwarded thru our dead IREs */
 892         u_long  ipif_ib_pkt_count;      /* Inbound packets for our dead IREs */
 893         u_long  ipif_ob_pkt_count;      /* Outbound packets to our dead IREs */
 894         unsigned int
 895                 ipif_multicast_up : 1,  /* We have joined the allhosts group */
 896                 : 0;
 897 } ipif_t;
 898
 899 typedef struct ipfb_s {                 /**/
 900         struct ipf_s    * ipfb_ipf;     /* List of ... */
 901         kmutex_t        ipfb_lock;      /* Protect all ipf in list */
 902 } ipfb_t;
 903
 904 typedef struct ilm_s {                  /**/
 905         afs_int32               ilm_addr;
 906         int             ilm_refcnt;
 907         u_int           ilm_timer;      /* IGMP */
 908         struct ipif_s   * ilm_ipif;     /* Back pointer to ipif */
 909         struct ilm_s    * ilm_next;     /* Linked list for each ill */
 910 } ilm_t;
 911
 912 typedef struct ill_s {                  /**/
 913         struct  ill_s   * ill_next;     /* Chained in at ill_g_head. */
 914         struct  ill_s   ** ill_ptpn;    /* Pointer to previous next. */
 915         queue_t * ill_rq;               /* Read queue. */
 916         queue_t * ill_wq;               /* Write queue. */
 917
 918         int     ill_error;              /* Error value sent up by device. */
 919
 920         ipif_t  * ill_ipif;             /* Interface chain for this ILL. */
 921         u_int   ill_ipif_up_count;      /* Number of IPIFs currently up. */
 922         u_int   ill_max_frag;           /* Max IDU. */
 923         char    * ill_name;             /* Our name. */
 924         u_int   ill_name_length;        /* Name length, incl. terminator. */
 925         u_int   ill_subnet_type;        /* IRE_RESOLVER or IRE_SUBNET. */
 926         u_int   ill_ppa;                /* Physical Point of Attachment num. */
 927         u_long  ill_sap;
 928         int     ill_sap_length;         /* Including sign (for position) */
 929         u_int   ill_phys_addr_length;   /* Excluding the sap. */
 930         mblk_t  * ill_frag_timer_mp;    /* Reassembly timer state. */
 931         ipfb_t  * ill_frag_hash_tbl;    /* Fragment hash list head. */
 932
 933         queue_t * ill_bind_pending_q;   /* Queue waiting for DL_BIND_ACK. */
 934         ipif_t  * ill_ipif_pending;     /* IPIF waiting for DL_BIND_ACK. */
 935
 936         /* ill_hdr_length and ill_hdr_mp will be non zero if
 937          * the underlying device supports the M_DATA fastpath
 938          */
 939         int     ill_hdr_length;
 940
 941         ilm_t   * ill_ilm;              /* Multicast mebership for lower ill */
 942
 943         /* All non-nil cells between 'ill_first_mp_to_free' and
 944          * 'ill_last_mp_to_free' are freed in ill_delete.
 945          */
 946 #define ill_first_mp_to_free    ill_hdr_mp
 947         mblk_t  * ill_hdr_mp;           /* Contains fastpath template */
 948         mblk_t  * ill_bcast_mp;         /* DLPI header for broadcasts. */
 949         mblk_t  * ill_bind_pending;     /* T_BIND_REQ awaiting completion. */
 950         mblk_t  * ill_resolver_mp;      /* Resolver template. */
 951         mblk_t  * ill_attach_mp;
 952         mblk_t  * ill_bind_mp;
 953         mblk_t  * ill_unbind_mp;
 954         mblk_t  * ill_detach_mp;
 955 #define ill_last_mp_to_free     ill_detach_mp
 956
 957         u_int
 958                 ill_frag_timer_running : 1,
 959                 ill_needs_attach : 1,
 960                 ill_is_ptp : 1,
 961                 ill_priv_stream : 1,
 962                 ill_unbind_pending : 1,
 963
 964                 ill_pad_to_bit_31 : 27;
 965         MI_HRT_DCL(ill_rtime)
 966         MI_HRT_DCL(ill_rtmp)
 967 } ill_t;
 968 #endif
 969
 970 #ifdef AFS_USERSPACE_IP_ADDR
 971 #ifndef afs_min
 972 #define afs_min(A,B) ((A)<(B)) ? (A) : (B)
 973 #endif
 974 /*
 975  * The IP addresses and ranks are determined by afsd (in user space) and
 976  * passed into the kernel at startup time through the AFSOP_ADVISEADDR
 977  * system call. These are stored in the data structure
 978  * called 'afs_cb_interface'.
 979  */
 980 afsi_SetServerIPRank(sa, addr, subnetmask)
 981    struct srvAddr *sa;         /* remote server */
 982    afs_int32 addr;                 /* one of my local addr in net order  */
 983    afs_uint32 subnetmask;         /* subnet mask of local addr in net order */
 984 {
 985    afs_uint32 myAddr, myNet, mySubnet, netMask;
 986    afs_uint32 serverAddr ;
 987
 988    myAddr = ntohl(addr);          /* one of my IP addr in host order */
 989    serverAddr = ntohl(sa->sa_ip); /* server's IP addr in host order */
 990    subnetmask = ntohl(subnetmask);/* subnet mask in host order */
 991
 992    if      ( IN_CLASSA(myAddr) ) netMask = IN_CLASSA_NET;
 993    else if ( IN_CLASSB(myAddr) ) netMask = IN_CLASSB_NET;
 994    else if ( IN_CLASSC(myAddr) ) netMask = IN_CLASSC_NET;
 995    else                          netMask = 0;
 996
 997    myNet    =  myAddr & netMask;
 998    mySubnet =  myAddr & subnetmask;
 999
1000    if ( (serverAddr & netMask ) == myNet ) {
1001       if ( (serverAddr & subnetmask ) == mySubnet) {
1002          if ( serverAddr == myAddr ) {    /* same machine */
1003            sa->sa_iprank = afs_min(sa->sa_iprank, TOPR);
1004          } else {                           /* same subnet */
1005             sa->sa_iprank = afs_min(sa->sa_iprank, HI);
1006          }
1007       } else {                               /* same net */
1008          sa->sa_iprank = afs_min(sa->sa_iprank, MED);
1009       }
1010    }
1011 }
1012 #else /* AFS_USERSPACE_IP_ADDR */
1013 #if (! defined(AFS_SUN5_ENV)) && defined(USEIFADDR)
1014 void
1015 afsi_SetServerIPRank(sa, ifa)
1016     struct srvAddr *sa;
1017     struct in_ifaddr *ifa;
1018 {
1019     struct sockaddr_in *sin;
1020     int t;
1021
1022     if ((ntohl(sa->sa_ip) & ifa->ia_netmask) == ifa->ia_net) {
1023         if ((ntohl(sa->sa_ip) & ifa->ia_subnetmask) == ifa->ia_subnet) {
1024             sin=IA_SIN(ifa);
1025             if ( SA2ULONG(sin) == ntohl(sa->sa_ip)) {   /* ie, ME!!!  */
1026                 sa->sa_iprank = TOPR;
1027             } else {
1028                 t = HI + ifa->ia_ifp->if_metric; /* case #2 */
1029                 if (sa->sa_iprank > t)
1030                     sa->sa_iprank = t;
1031             }
1032         } else {
1033             t = MED + ifa->ia_ifp->if_metric;/* case #3 */
1034             if (sa->sa_iprank > t)
1035                 sa->sa_iprank = t;
1036         }
1037     }
1038 #ifdef  IFF_POINTTOPOINT
1039     /* check for case #4 -- point-to-point link */
1040     if ((ifa->ia_ifp->if_flags & IFF_POINTOPOINT) &&
1041         (SA2ULONG(IA_DST(ifa)) == ntohl(sa->sa_ip))) {
1042         if (ifa->ia_ifp->if_metric >= (MAXDEFRANK - MED)/PPWEIGHT)
1043             t = MAXDEFRANK;
1044         else
1045             t = MED + (PPWEIGHT << ifa->ia_ifp->if_metric);
1046         if (sa->sa_iprank > t)
1047             sa->sa_iprank = t;
1048     }
1049 #endif /* IFF_POINTTOPOINT */
1050 }
1051 #endif /*(!defined(AFS_SUN5_ENV)) && defined(USEIFADDR)*/
1052 #endif /* else AFS_USERSPACE_IP_ADDR */
1053
1054 #ifdef AFS_SGI62_ENV
1055 static int
1056 afsi_enum_set_rank(struct hashbucket *h, caddr_t mkey, caddr_t arg1,
1057                 caddr_t arg2)
1058 {
1059    afsi_SetServerIPRank((struct srvAddr *)arg1, (struct in_ifaddr*)h);
1060    return 0; /* Never match, so we enumerate everyone */
1061 }
1062 #endif /* AFS_SGI62_ENV */
1063
1064 static afs_SetServerPrefs(sa)
1065     struct srvAddr *sa;
1066 {
1067 #if     defined(AFS_USERSPACE_IP_ADDR)
1068     extern interfaceAddr afs_cb_interface;
1069     int i;
1070
1071     sa->sa_iprank = LO;
1072     for (i=0; i<afs_cb_interface.numberOfInterfaces; i++) {
1073        afsi_SetServerIPRank(sa, afs_cb_interface.addr_in[i],
1074                                 afs_cb_interface.subnetmask[i]);
1075     }
1076 #else   /* AFS_USERSPACE_IP_ADDR */
1077 #if     defined(AFS_SUN5_ENV)
1078     extern struct ill_s *ill_g_headp;
1079     ill_t *ill;
1080     ipif_t * ipif;
1081     int subnet, subnetmask, net, netmask;
1082     long *addr = (long *) ill_g_headp;
1083     extern struct ifnet *rxi_FindIfnet();
1084
1085     if (sa) sa->sa_iprank= 0;
1086     for (ill = (struct ill_s *)*addr /*ill_g_headp*/; ill; ill = ill->ill_next ) {
1087 #ifdef AFS_SUN58_ENV
1088         /* Make sure this is an IPv4 ILL */
1089         if (ill->ill_isv6) continue;
1090 #endif
1091         for (ipif = ill->ill_ipif; ipif; ipif = ipif->ipif_next ) {
1092             subnet = ipif->ipif_local_addr & ipif->ipif_net_mask;
1093             subnetmask = ipif->ipif_net_mask;
1094             /*
1095              * Generate the local net using the local address and
1096              * whate we know about Class A, B and C networks.
1097              */
1098             if (IN_CLASSA(ipif->ipif_local_addr)) {
1099                 netmask = IN_CLASSA_NET;
1100             } else if (IN_CLASSB(ipif->ipif_local_addr)) {
1101                 netmask = IN_CLASSB_NET;
1102             } else if (IN_CLASSC(ipif->ipif_local_addr)) {
1103                 netmask = IN_CLASSC_NET;
1104             } else {
1105                 netmask = 0;
1106             }
1107             net = ipif->ipif_local_addr & netmask;
1108 #ifdef notdef
1109             if (!s) {
1110                 if (ipif->ipif_local_addr != 0x7f000001) { /* ignore loopback */
1111                     *cnt += 1;
1112                     if (*cnt > 16) return;
1113                     *addrp++ = ipif->ipif_local_addr;
1114                 }
1115             } else
1116 #endif /* notdef */
1117               {
1118                 /* XXXXXX Do the individual ip ranking below XXXXX */
1119                 if ((sa->sa_ip & netmask) == net) {
1120                     if ((sa->sa_ip & subnetmask) == subnet) {
1121                         if (ipif->ipif_local_addr == sa->sa_ip) {  /* ie, ME!  */
1122                             sa->sa_iprank = TOPR;
1123                         } else {
1124                             sa->sa_iprank = HI + ipif->ipif_metric; /* case #2 */
1125                         }
1126                     }  else {
1127                         sa->sa_iprank = MED + ipif->ipif_metric;   /* case #3 */
1128                     }
1129                 } else {
1130                     sa->sa_iprank = LO + ipif->ipif_metric;     /* case #4 */
1131                 }
1132                 /* check for case #5 -- point-to-point link */
1133                 if ((ipif->ipif_flags & IFF_POINTOPOINT) &&
1134                     (ipif->ipif_pp_dst_addr == sa->sa_ip )) {
1135
1136                     if (ipif->ipif_metric >= (MAXDEFRANK - MED)/PPWEIGHT)
1137                         sa->sa_iprank = MAXDEFRANK;
1138                     else
1139                         sa->sa_iprank = MED + (PPWEIGHT << ipif->ipif_metric);
1140                 }
1141             }
1142         }
1143     }
1144 #else
1145 #ifndef USEIFADDR
1146     struct ifnet *ifn = (struct ifnet *)0;
1147     struct in_ifaddr *ifad = (struct in_ifaddr *) 0;
1148     struct sockaddr_in *sin;
1149
1150     if (!sa) {
1151 #ifdef notdef /* clean up, remove this */
1152         for (ifn = ifnet; ifn != NULL; ifn = ifn->if_next) {
1153             for (ifad = ifn->if_addrlist; ifad != NULL; ifad = ifad->ifa_next){
1154                if ((IFADDR2SA(ifad)->sa_family == AF_INET)
1155                    && !(ifn->if_flags & IFF_LOOPBACK)) {
1156                   *cnt += 1;
1157                   if (*cnt > 16) return;
1158                   *addrp++ = ((struct sockaddr_in *) IFADDR2SA(ifad))->sin_addr.s_addr;
1159                 }
1160             }
1161         }
1162 #endif /* notdef */
1163         return;
1164     }
1165     sa->sa_iprank= 0;
1166 #ifdef  ADAPT_MTU
1167     ifn = rxi_FindIfnet(sa->sa_ip, &ifad);
1168 #endif
1169     if (ifn) {  /* local, more or less */
1170 #ifdef IFF_LOOPBACK
1171       if (ifn->if_flags & IFF_LOOPBACK) {
1172         sa->sa_iprank = TOPR;
1173         goto end;
1174       }
1175 #endif /* IFF_LOOPBACK */
1176       sin = (struct sockaddr_in *) IA_SIN(ifad);
1177       if (SA2ULONG(sin) == sa->sa_ip) {
1178         sa->sa_iprank = TOPR;
1179         goto end;
1180       }
1181 #ifdef IFF_BROADCAST
1182       if (ifn->if_flags & IFF_BROADCAST) {
1183          if (sa->sa_ip == (sa->sa_ip & SA2ULONG(IA_BROAD(ifad)))) {
1184             sa->sa_iprank = HI;
1185             goto end;
1186           }
1187        }
1188 #endif /* IFF_BROADCAST */
1189 #ifdef IFF_POINTOPOINT
1190       if (ifn->if_flags & IFF_POINTOPOINT) {
1191         if (sa->sa_ip == SA2ULONG(IA_DST(ifad))) {
1192           if (ifn->if_metric > 4) {
1193             sa->sa_iprank = LO;
1194             goto end;
1195           }
1196           else sa->sa_iprank = ifn->if_metric;
1197         }
1198       }
1199 #endif /* IFF_POINTOPOINT */
1200       sa->sa_iprank += MED + ifn->if_metric;      /* couldn't find anything better */
1201     }
1202
1203 #else /* USEIFADDR */
1204
1205     if (sa) sa->sa_iprank= LO;
1206 #ifdef AFS_SGI62_ENV
1207     (void) hash_enum(&hashinfo_inaddr, afsi_enum_set_rank, HTF_INET, NULL,
1208                      (caddr_t)sa, NULL);
1209 #elif defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
1210     {
1211         struct in_ifaddr *ifa;
1212         TAILQ_FOREACH(ifa , &in_ifaddrhead, ia_link) {
1213             afsi_SetServerIPRank(sa, ifa);
1214         }
1215     }
1216 #else
1217     {
1218         extern struct in_ifaddr *in_ifaddr;
1219         struct in_ifaddr *ifa;
1220         for ( ifa = in_ifaddr; ifa; ifa = ifa->ia_next ) {
1221             afsi_SetServerIPRank(sa, ifa);
1222         }
1223     }
1224 #endif
1225
1226 #endif /* USEIFADDR */
1227 #endif /* AFS_SUN5_ENV */
1228 #endif /* else AFS_USERSPACE_IP_ADDR */
1229
1230   end:
1231     if (sa) sa->sa_iprank += afs_randomMod15();
1232
1233 return 0;
1234 }  /* afs_SetServerPrefs */
1235 #undef TOPR
1236 #undef HI
1237 #undef MED
1238 #undef LO
1239 #undef PPWEIGHT
1240
1241 /* afs_FlushServer()
1242  * The addresses on this server struct has changed in some way and will
1243  * clean up all other structures that may reference it.
1244  * The afs_xserver and afs_xsrvAddr locks are assumed taken.
1245  */
1246 void afs_FlushServer(srvp)
1247   struct server *srvp;
1248 {
1249   afs_int32 i;
1250   struct server  *ts, **pts;
1251
1252   /* Find any volumes residing on this server and flush their state */
1253   afs_ResetVolumes(srvp);
1254
1255   /* Flush all callbacks in the all vcaches for this specific server */
1256   afs_FlushServerCBs(srvp);
1257
1258   /* Remove all the callbacks structs */
1259   if (srvp->cbrs) {
1260      struct afs_cbr *cb, *cbnext;
1261      extern afs_lock_t afs_xvcb;
1262
1263      MObtainWriteLock(&afs_xvcb, 300);
1264      for (cb=srvp->cbrs; cb; cb=cbnext) {
1265         cbnext = cb->next;
1266         afs_FreeCBR(cb);
1267      }
1268      srvp->cbrs = (struct afs_cbr *)0;
1269      ReleaseWriteLock(&afs_xvcb);
1270   }
1271
1272   /* If no more srvAddr structs hanging off of this server struct,
1273    * then clean it up.
1274    */
1275   if (!srvp->addr) {
1276      /* Remove the server structure from the cell list - if there */
1277      afs_RemoveCellEntry(srvp);
1278
1279      /* Remove from the afs_servers hash chain */
1280      for (i=0; i<NSERVERS; i++) {
1281         for (pts=&(afs_servers[i]), ts=*pts; ts; pts=&(ts->next), ts=*pts) {
1282            if (ts == srvp) break;
1283         }
1284         if (ts) break;
1285      }
1286      if (ts) {
1287         *pts = ts->next;                /* Found it. Remove it */
1288         afs_osi_Free(ts, sizeof(struct server)); /* Free it */
1289         afs_totalServers--;
1290      }
1291   }
1292 }
1293
1294 /* afs_RemoveSrvAddr()
1295  * This removes a SrvAddr structure from its server structure.
1296  * The srvAddr struct is not free'd because it connections may still
1297  * be open to it. It is up to the calling process to make sure it
1298  * remains connected to a server struct.
1299  * The afs_xserver and afs_xsrvAddr locks are assumed taken.
1300  *    It is not removed from the afs_srvAddrs hash chain.
1301  */
1302 void afs_RemoveSrvAddr(sap)
1303   struct srvAddr *sap;
1304 {
1305   struct srvAddr **psa, *sa;
1306   struct server  *srv;
1307
1308   if (!sap) return;
1309   srv = sap->server;
1310
1311   /* Find the srvAddr in the server's list and remove it */
1312   for (psa=&(srv->addr), sa=*psa; sa; psa=&(sa->next_sa), sa=*psa) {
1313      if (sa == sap) break;
1314   }
1315   if (sa) {
1316      *psa = sa->next_sa;
1317      sa->next_sa = 0;
1318      sa->server  = 0;
1319
1320      /* Flush the server struct since it's IP address has changed */
1321      afs_FlushServer(srv);
1322   }
1323 }
1324
1325 /* afs_GetServer()
1326  * Return an updated and properly initialized server structure
1327  * corresponding to the server ID, cell, and port specified.
1328  * If one does not exist, then one will be created.
1329  * aserver and aport must be in NET byte order.
1330  */
1331 struct server *afs_GetServer(afs_uint32 *aserverp, afs_int32 nservers,
1332                              afs_int32 acell, u_short aport,
1333                              afs_int32 locktype, afsUUID *uuidp,
1334                              afs_int32 addr_uniquifier)
1335 {
1336     struct server  *oldts=0, *ts, *newts, *orphts=0;
1337     struct srvAddr *oldsa, *sa, *newsa, *nextsa, *orphsa;
1338     u_short fsport;
1339     afs_int32 iphash, k, srvcount=0;
1340     unsigned int srvhash;
1341
1342     AFS_STATCNT(afs_GetServer);
1343
1344     ObtainSharedLock(&afs_xserver,13);
1345
1346     /* Check if the server struct exists and is up to date */
1347     if (!uuidp) {
1348        if (nservers != 1) panic("afs_GetServer: incorect count of servers");
1349        ObtainReadLock(&afs_xsrvAddr);
1350        ts = afs_FindServer(aserverp[0], aport, NULL, locktype);
1351        ReleaseReadLock(&afs_xsrvAddr);
1352        if (ts && !(ts->flags & SRVR_MULTIHOMED)) {
1353           /* Found a server struct that is not multihomed and has the
1354            * IP address associated with it. A correct match.
1355            */
1356           ReleaseSharedLock(&afs_xserver);
1357           return(ts);
1358        }
1359     } else {
1360        if (nservers <= 0) panic("afs_GetServer: incorrect count of servers");
1361        ts = afs_FindServer(0, aport, uuidp, locktype);
1362        if (ts && (ts->sr_addr_uniquifier == addr_uniquifier) && ts->addr) {
1363           /* Found a server struct that is multihomed and same
1364            * uniqufier (same IP addrs). The above if statement is the
1365            * same as in InstallUVolumeEntry().
1366            */
1367           ReleaseSharedLock(&afs_xserver);
1368           return ts;
1369        }
1370        if (ts) oldts = ts;      /* Will reuse if same uuid */
1371     }
1372
1373     UpgradeSToWLock(&afs_xserver,36);
1374     ObtainWriteLock(&afs_xsrvAddr,116);
1375
1376     srvcount = afs_totalServers;
1377
1378     /* Reuse/allocate a new server structure */
1379     if (oldts) {
1380        newts = oldts;
1381     } else {
1382        newts = (struct server *) afs_osi_Alloc(sizeof(struct server));
1383        if (!newts) panic("malloc of server struct");
1384        afs_totalServers++;
1385        memset((char *)newts, 0, sizeof(struct server));
1386
1387        /* Add the server struct to the afs_servers[] hash chain */
1388        srvhash = (uuidp ? (afs_uuid_hash(uuidp)%NSERVERS) : SHash(aserverp[0]));
1389        newts->next = afs_servers[srvhash];
1390        afs_servers[srvhash] = newts;
1391     }
1392
1393     /* Initialize the server structure */
1394     if (uuidp) { /* Multihomed */
1395        newts->sr_uuid            = *uuidp;
1396        newts->sr_addr_uniquifier = addr_uniquifier;
1397        newts->flags             |= SRVR_MULTIHOMED;
1398     }
1399     if (acell) newts->cell = afs_GetCell(acell, 0);
1400
1401     fsport = (newts->cell ? newts->cell->fsport : AFS_FSPORT);
1402
1403     /* For each IP address we are registering */
1404     for (k=0; k<nservers; k++) {
1405        iphash = SHash(aserverp[k]);
1406
1407        /* Check if the srvAddr structure already exists. If so, remove
1408         * it from its server structure and add it to the new one.
1409         */
1410        for (oldsa=afs_srvAddrs[iphash]; oldsa; oldsa=oldsa->next_bkt) {
1411           if ( (oldsa->sa_ip == aserverp[k]) && (oldsa->sa_portal == aport) ) break;
1412        }
1413        if (oldsa && (oldsa->server != newts)) {
1414           afs_RemoveSrvAddr(oldsa);     /* Remove from its server struct */
1415           oldsa->next_sa = newts->addr; /* Add to the  new server struct */
1416           newts->addr    = oldsa;
1417        }
1418
1419        /* Reuse/allocate a new srvAddr structure */
1420        if (oldsa) {
1421           newsa = oldsa;
1422        } else {
1423           newsa = (struct srvAddr *) afs_osi_Alloc(sizeof(struct srvAddr));
1424           if (!newsa) panic("malloc of srvAddr struct");
1425           afs_totalSrvAddrs++;
1426           memset((char *)newsa, 0, sizeof(struct srvAddr));
1427
1428           /* Add the new srvAddr to the afs_srvAddrs[] hash chain */
1429           newsa->next_bkt = afs_srvAddrs[iphash];
1430           afs_srvAddrs[iphash] = newsa;
1431
1432           /* Hang off of the server structure  */
1433           newsa->next_sa = newts->addr;
1434           newts->addr    = newsa;
1435
1436           /* Initialize the srvAddr Structure */
1437           newsa->sa_ip     = aserverp[k];
1438           newsa->sa_portal = aport;
1439        }
1440
1441        /* Update the srvAddr Structure */
1442        newsa->server    = newts;
1443        if (newts->flags & SRVR_ISDOWN)
1444           newsa->sa_flags |= SRVADDR_ISDOWN;
1445        if (uuidp) newsa->sa_flags |=  SRVADDR_MH;
1446        else       newsa->sa_flags &= ~SRVADDR_MH;
1447
1448        /* Compute preference values and resort */
1449        if (!newsa->sa_iprank) {
1450           if (aport == fsport) {
1451              afs_SetServerPrefs(newsa);    /* new fileserver rank */
1452           } else {
1453              newsa->sa_iprank = 10000 + afs_randomMod127(); /* new vlserver rank */
1454           }
1455        }
1456     }
1457     afs_SortOneServer(newts);     /* Sort by rank */
1458
1459     /* If we reused the server struct, remove any of its srvAddr
1460      * structs that will no longer be associated with this server.
1461      */
1462     if (oldts) {    /* reused the server struct */
1463        for (orphsa=newts->addr; orphsa; orphsa=nextsa) {
1464           nextsa = orphsa->next_sa;
1465           for (k=0; k<nservers; k++) {
1466              if (orphsa->sa_ip == aserverp[k]) break; /* belongs */
1467           }
1468           if (k < nservers) continue;                 /* belongs */
1469
1470           /* Have a srvAddr struct. Now get a server struct (if not already) */
1471           if (!orphts) {
1472              orphts = (struct server *) afs_osi_Alloc(sizeof(struct server));
1473              if (!orphts) panic("malloc of lo server struct");
1474              memset((char *)orphts, 0, sizeof(struct server));
1475              afs_totalServers++;
1476
1477              /* Add the orphaned server to the afs_servers[] hash chain.
1478               * Its iphash does not matter since we never look up the server
1479               * in the afs_servers table by its ip address (only by uuid -
1480               * which this has none).
1481               */
1482              iphash = SHash(aserverp[k]);
1483              orphts->next = afs_servers[iphash];
1484              afs_servers[iphash] = orphts;
1485
1486              if (acell) orphts->cell = afs_GetCell(acell, 0);
1487           }
1488
1489           /* Hang the srvAddr struct off of the server structure. The server
1490            * may have multiple srvAddrs, but it won't be marked multihomed.
1491            */
1492           afs_RemoveSrvAddr(orphsa);                 /* remove */
1493           orphsa->next_sa   = orphts->addr;          /* hang off server struct */
1494           orphts->addr      = orphsa;
1495           orphsa->server    = orphts;
1496           orphsa->sa_flags |= SRVADDR_NOUSE;         /* flag indicating not in use */
1497           orphsa->sa_flags &= ~SRVADDR_MH;           /* Not multihomed */
1498        }
1499     }
1500
1501     srvcount = afs_totalServers - srvcount;  /* # servers added and removed */
1502     if (srvcount) {
1503        struct afs_stats_SrvUpDownInfo *upDownP;
1504        /* With the introduction of this new record, we need to adjust the
1505         * proper individual & global server up/down info.
1506         */
1507        if (aport == fsport) {   /* File Server record */
1508           upDownP = (acell == 1) ?
1509             &(afs_stats_cmperf.fs_UpDown[AFS_STATS_UPDOWN_IDX_SAME_CELL]) :
1510             &(afs_stats_cmperf.fs_UpDown[AFS_STATS_UPDOWN_IDX_DIFF_CELL]);
1511        } else {                   /* VL Server record */
1512           upDownP = (acell == 1) ?
1513             &(afs_stats_cmperf.vl_UpDown[AFS_STATS_UPDOWN_IDX_SAME_CELL]) :
1514             &(afs_stats_cmperf.vl_UpDown[AFS_STATS_UPDOWN_IDX_DIFF_CELL]);
1515        }
1516        (upDownP->numTtlRecords)    += srvcount;
1517        afs_stats_cmperf.srvRecords += srvcount;
1518        if (afs_stats_cmperf.srvRecords > afs_stats_cmperf.srvRecordsHWM)
1519           afs_stats_cmperf.srvRecordsHWM = afs_stats_cmperf.srvRecords;
1520     }
1521
1522     ReleaseWriteLock(&afs_xsrvAddr);
1523     ReleaseWriteLock(&afs_xserver);
1524     return(newts);
1525 } /* afs_GetServer */
1526
1527 void afs_ActivateServer(sap)
1528      struct srvAddr *sap;
1529 {
1530    osi_timeval_t currTime;              /*Filled with current time*/
1531    osi_timeval_t *currTimeP;            /*Ptr to above*/
1532    struct afs_stats_SrvUpDownInfo *upDownP; /*Ptr to up/down info record*/
1533    struct server *aserver = sap->server;
1534
1535    if (!(aserver->flags & AFS_SERVER_FLAG_ACTIVATED)) {
1536       /*
1537        * This server record has not yet been activated.  Go for it,
1538        * recording its ``birth''.
1539        */
1540       aserver->flags |= AFS_SERVER_FLAG_ACTIVATED;
1541       currTimeP = &currTime;
1542       osi_GetuTime(currTimeP);
1543       aserver->activationTime = currTime.tv_sec;
1544       if (sap->sa_portal == AFS_FSPORT) {
1545          upDownP = (aserver->cell->cell == 1) ?
1546               &(afs_stats_cmperf.fs_UpDown[AFS_STATS_UPDOWN_IDX_SAME_CELL]) :
1547                    &(afs_stats_cmperf.fs_UpDown[AFS_STATS_UPDOWN_IDX_DIFF_CELL]);
1548       } /*File Server record*/
1549       else {
1550          upDownP = (aserver->cell->cell == 1) ?
1551               &(afs_stats_cmperf.vl_UpDown[AFS_STATS_UPDOWN_IDX_SAME_CELL]) :
1552                    &(afs_stats_cmperf.vl_UpDown[AFS_STATS_UPDOWN_IDX_DIFF_CELL]);
1553       } /*VL Server record*/
1554       if (aserver->flags & SRVR_ISDOWN)
1555            (upDownP->numDownRecords)++;
1556       else {
1557          (upDownP->numUpRecords)++;
1558          (upDownP->numRecordsNeverDown)++;
1559       }
1560    }
1561 }