afs: Remove osi_GetuTime
[openafs.git] / 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
36 #include "afs/stds.h"
37 #include "afs/sysincludes.h"    /* Standard vendor system headers */
38
39 #if !defined(UKERNEL)
40 #if !defined(AFS_LINUX20_ENV)
41 #include <net/if.h>
42 #endif
43 #include <netinet/in.h>
44
45 #ifdef AFS_SGI62_ENV
46 #include "h/hashing.h"
47 #endif
48 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV)
49 #include <netinet/in_var.h>
50 #endif /* AFS_HPUX110_ENV */
51 #ifdef AFS_DARWIN_ENV
52 #include <net/if_var.h>
53 #endif
54 #endif /* !defined(UKERNEL) */
55
56 #include "afsincludes.h"        /* Afs-based standard headers */
57 #include "afs/afs_stats.h"      /* afs statistics */
58 #include "rx/rx_multi.h"
59
60 #if     defined(AFS_SUN5_ENV)
61 #include <inet/led.h>
62 #include <inet/common.h>
63 #include <netinet/ip6.h>
64 #define ipif_local_addr ipif_lcl_addr
65 #ifndef V4_PART_OF_V6
66 # define V4_PART_OF_V6(v6)       v6.s6_addr32[3]
67 #endif
68 #include <inet/ip.h>
69 #endif
70
71 /* Exported variables */
72 afs_rwlock_t afs_xserver;       /* allocation lock for servers */
73 struct server *afs_servers[NSERVERS];   /* Hashed by server`s uuid & 1st ip */
74 afs_rwlock_t afs_xsrvAddr;      /* allocation lock for srvAddrs */
75 struct srvAddr *afs_srvAddrs[NSERVERS]; /* Hashed by server's ip */
76
77
78 /* debugging aids - number of alloc'd server and srvAddr structs. */
79 int afs_reuseServers = 0;
80 int afs_reuseSrvAddrs = 0;
81 int afs_totalServers = 0;
82 int afs_totalSrvAddrs = 0;
83
84
85
86 static struct afs_stats_SrvUpDownInfo *
87 GetUpDownStats(struct server *srv)
88 {
89     struct afs_stats_SrvUpDownInfo *upDownP;
90     u_short fsport = AFS_FSPORT;
91
92     if (srv->cell)
93         fsport = srv->cell->fsport;
94
95     if (srv->addr->sa_portal == fsport)
96         upDownP = afs_stats_cmperf.fs_UpDown;
97     else
98         upDownP = afs_stats_cmperf.vl_UpDown;
99
100     if (srv->cell && afs_IsPrimaryCell(srv->cell))
101         return &upDownP[AFS_STATS_UPDOWN_IDX_SAME_CELL];
102     else
103         return &upDownP[AFS_STATS_UPDOWN_IDX_DIFF_CELL];
104 }
105
106
107 /*------------------------------------------------------------------------
108  * afs_MarkServerUpOrDown
109  *
110  * Description:
111  *      Mark the given server up or down, and track its uptime stats.
112  *
113  * Arguments:
114  *      a_serverP : Ptr to server record to fiddle with.
115  *      a_isDown  : Is the server is to be marked down?
116  *
117  * Returns:
118  *      Nothing.
119  *
120  * Environment:
121  *      The CM server structures must be write-locked.
122  *
123  * Side Effects:
124  *      As advertised.
125  *------------------------------------------------------------------------*/
126
127 void
128 afs_MarkServerUpOrDown(struct srvAddr *sa, int a_isDown)
129 {
130     struct server *a_serverP = sa->server;
131     struct srvAddr *sap;
132     osi_timeval32_t currTime, *currTimeP;       /*Current time */
133     afs_int32 downTime;         /*Computed downtime, in seconds */
134     struct afs_stats_SrvUpDownInfo *upDownP;    /*Ptr to up/down info record */
135
136     /*
137      * If the server record is marked the same as the new status we've
138      * been fed, then there isn't much to be done.
139      */
140     if ((a_isDown && (sa->sa_flags & SRVADDR_ISDOWN))
141         || (!a_isDown && !(sa->sa_flags & SRVADDR_ISDOWN)))
142         return;
143
144     if (a_isDown) {
145         sa->sa_flags |= SRVADDR_ISDOWN;
146         for (sap = a_serverP->addr; sap; sap = sap->next_sa) {
147             if (!(sap->sa_flags & SRVADDR_ISDOWN)) {
148                 /* Not all ips are up so don't bother with the
149                  * server's up/down stats */
150                 return;
151             }
152         }
153         /*
154          * All ips are down we treat the whole server down
155          */
156         a_serverP->flags |= SRVR_ISDOWN;
157     } else {
158         sa->sa_flags &= ~SRVADDR_ISDOWN;
159         /* If any ips are up, the server is also marked up */
160         a_serverP->flags &= ~SRVR_ISDOWN;
161         for (sap = a_serverP->addr; sap; sap = sap->next_sa) {
162             if (sap->sa_flags & SRVADDR_ISDOWN) {
163                 /* Not all ips are up so don't bother with the
164                  * server's up/down stats */
165                 return;
166             }
167         }
168     }
169 #ifndef AFS_NOSTATS
170     /*
171      * Compute the current time and which overall stats record is to be
172      * updated; we'll need them one way or another.
173      */
174     currTimeP = &currTime;
175     osi_GetTime(currTimeP);
176
177     upDownP = GetUpDownStats(a_serverP);
178
179     if (a_isDown) {
180         /*
181          * Server going up -> down; remember the beginning of this
182          * downtime incident.
183          */
184         a_serverP->lastDowntimeStart = currTime.tv_sec;
185
186         (upDownP->numDownRecords)++;
187         (upDownP->numUpRecords)--;
188     } /*Server being marked down */
189     else {
190         /*
191          * Server going down -> up; remember everything about this
192          * newly-completed downtime incident.
193          */
194         downTime = currTime.tv_sec - a_serverP->lastDowntimeStart;
195         (a_serverP->numDowntimeIncidents)++;
196         a_serverP->sumOfDowntimes += downTime;
197
198         (upDownP->numUpRecords)++;
199         (upDownP->numDownRecords)--;
200         (upDownP->numDowntimeIncidents)++;
201         if (a_serverP->numDowntimeIncidents == 1)
202             (upDownP->numRecordsNeverDown)--;
203         upDownP->sumOfDowntimes += downTime;
204         if ((upDownP->shortestDowntime == 0)
205             || (downTime < upDownP->shortestDowntime))
206             upDownP->shortestDowntime = downTime;
207         if ((upDownP->longestDowntime == 0)
208             || (downTime > upDownP->longestDowntime))
209             upDownP->longestDowntime = downTime;
210
211
212         if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET0)
213             (upDownP->downDurations[0])++;
214         else if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET1)
215             (upDownP->downDurations[1])++;
216         else if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET2)
217             (upDownP->downDurations[2])++;
218         else if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET3)
219             (upDownP->downDurations[3])++;
220         else if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET4)
221             (upDownP->downDurations[4])++;
222         else if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET5)
223             (upDownP->downDurations[5])++;
224         else
225             (upDownP->downDurations[6])++;
226
227     }                           /*Server being marked up */
228 #endif
229 }                               /*MarkServerUpOrDown */
230
231
232 afs_int32
233 afs_ServerDown(struct srvAddr *sa, int code, struct rx_connection *rxconn)
234 {
235     struct server *aserver = sa->server;
236
237     AFS_STATCNT(ServerDown);
238     if (aserver->flags & SRVR_ISDOWN || sa->sa_flags & SRVADDR_ISDOWN)
239         return 0;
240     afs_MarkServerUpOrDown(sa, SRVR_ISDOWN);
241     if (sa->sa_portal == aserver->cell->vlport)
242         print_internet_address("afs: Lost contact with volume location server ",
243                               sa, "", 1, code, rxconn);
244     else
245         print_internet_address("afs: Lost contact with file server ", sa, "",
246                                1, code, rxconn);
247     return 1;
248 }                               /*ServerDown */
249
250
251 /* return true if we have any callback promises from this server */
252 int
253 afs_HaveCallBacksFrom(struct server *aserver)
254 {
255     afs_int32 now;
256     int i;
257     struct vcache *tvc;
258
259     AFS_STATCNT(HaveCallBacksFrom);
260     now = osi_Time();           /* for checking for expired callbacks */
261     for (i = 0; i < VCSIZE; i++) {      /* for all guys in the hash table */
262         for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
263             /*
264              * Check to see if this entry has an unexpired callback promise
265              * from the required host
266              */
267             if (aserver == tvc->callback && tvc->cbExpires >= now
268                 && ((tvc->f.states & CRO) == 0))
269                 return 1;
270         }
271     }
272     return 0;
273
274 }                               /*HaveCallBacksFrom */
275
276
277 static void
278 CheckVLServer(struct srvAddr *sa, struct vrequest *areq)
279 {
280     struct server *aserver = sa->server;
281     struct afs_conn *tc;
282     afs_int32 code;
283     struct rx_connection *rxconn;
284
285     AFS_STATCNT(CheckVLServer);
286     /* Ping dead servers to see if they're back */
287     if (!((aserver->flags & SRVR_ISDOWN) || (sa->sa_flags & SRVADDR_ISDOWN))
288         || (aserver->flags & SRVR_ISGONE))
289         return;
290     if (!aserver->cell)
291         return;                 /* can't do much */
292
293     tc = afs_ConnByHost(aserver, aserver->cell->vlport,
294                         aserver->cell->cellNum, areq, 1, SHARED_LOCK, 0,
295                         &rxconn);
296     if (!tc)
297         return;
298     rx_SetConnDeadTime(rxconn, 3);
299
300     RX_AFS_GUNLOCK();
301     code = VL_ProbeServer(rxconn);
302     RX_AFS_GLOCK();
303     rx_SetConnDeadTime(rxconn, afs_rx_deadtime);
304     /*
305      * If probe worked, or probe call not yet defined (for compatibility
306      * with old vlsevers), then we treat this server as running again
307      */
308     if (code == 0 || (code <= -450 && code >= -470)) {
309         if (tc->parent->srvr == sa) {
310             afs_MarkServerUpOrDown(sa, 0);
311             print_internet_address("afs: volume location server ", sa,
312                                    " is back up", 2, code, rxconn);
313         }
314     }
315     afs_PutConn(tc, rxconn, SHARED_LOCK);
316
317 }                               /*CheckVLServer */
318
319
320 #ifndef AFS_MINCHANGE           /* So that some can increase it in param.h */
321 #define AFS_MINCHANGE 2         /* min change we'll bother with */
322 #endif
323 #ifndef AFS_MAXCHANGEBACK
324 #define AFS_MAXCHANGEBACK 10    /* max seconds we'll set a clock back at once */
325 #endif
326
327
328 /*------------------------------------------------------------------------
329  * EXPORTED afs_CountServers
330  *
331  * Description:
332  *      Originally meant to count the number of servers and determining
333  *      up/down info, this routine will now simply sum up all of the
334  *      server record ages.  All other up/down information is kept on the
335  *      fly.
336  *
337  * Arguments:
338  *      None.
339  *
340  * Returns:
341  *      Nothing.
342  *
343  * Environment:
344  *      This routine locks afs_xserver for write for the duration.
345  *
346  * Side Effects:
347  *      Set CM perf stats field sumOfRecordAges for all server record
348  *      entries.
349  *------------------------------------------------------------------------*/
350
351 void
352 afs_CountServers(void)
353 {
354     int currIdx;                /*Curr idx into srv table */
355     struct server *currSrvP;    /*Ptr to curr server record */
356     afs_int32 currChainLen;     /*Length of curr hash chain */
357     osi_timeval32_t currTime;   /*Current time */
358     osi_timeval32_t *currTimeP; /*Ptr to above */
359     afs_int32 srvRecordAge;     /*Age of server record, in secs */
360     struct afs_stats_SrvUpDownInfo *upDownP;    /*Ptr to current up/down
361                                                  * info being manipulated */
362
363     /*
364      * Write-lock the server table so we don't get any interference.
365      */
366     ObtainReadLock(&afs_xserver);
367
368     /*
369      * Iterate over each hash index in the server table, walking down each
370      * chain and tallying what we haven't computed from the records there on
371      * the fly.  First, though, initialize the tallies that will change.
372      */
373     afs_stats_cmperf.srvMaxChainLength = 0;
374
375     afs_stats_cmperf.fs_UpDown[0].sumOfRecordAges = 0;
376     afs_stats_cmperf.fs_UpDown[0].ageOfYoungestRecord = 0;
377     afs_stats_cmperf.fs_UpDown[0].ageOfOldestRecord = 0;
378     memset(afs_stats_cmperf.fs_UpDown[0].downIncidents, 0,
379            AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
380
381     afs_stats_cmperf.fs_UpDown[1].sumOfRecordAges = 0;
382     afs_stats_cmperf.fs_UpDown[1].ageOfYoungestRecord = 0;
383     afs_stats_cmperf.fs_UpDown[1].ageOfOldestRecord = 0;
384     memset(afs_stats_cmperf.fs_UpDown[1].downIncidents, 0,
385            AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
386
387     afs_stats_cmperf.vl_UpDown[0].sumOfRecordAges = 0;
388     afs_stats_cmperf.vl_UpDown[0].ageOfYoungestRecord = 0;
389     afs_stats_cmperf.vl_UpDown[0].ageOfOldestRecord = 0;
390     memset(afs_stats_cmperf.vl_UpDown[0].downIncidents, 0,
391            AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
392
393     afs_stats_cmperf.vl_UpDown[1].sumOfRecordAges = 0;
394     afs_stats_cmperf.vl_UpDown[1].ageOfYoungestRecord = 0;
395     afs_stats_cmperf.vl_UpDown[1].ageOfOldestRecord = 0;
396     memset(afs_stats_cmperf.vl_UpDown[1].downIncidents, 0,
397            AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
398
399     /*
400      * Compute the current time, used to figure out server record ages.
401      */
402     currTimeP = &currTime;
403     osi_GetTime(currTimeP);
404
405     /*
406      * Sweep the server hash table, tallying all we need to know.
407      */
408     for (currIdx = 0; currIdx < NSERVERS; currIdx++) {
409         currChainLen = 0;
410         for (currSrvP = afs_servers[currIdx]; currSrvP;
411              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                 upDownP = GetUpDownStats(currSrvP);
430                 upDownP->sumOfRecordAges += srvRecordAge;
431                 if ((upDownP->ageOfYoungestRecord == 0)
432                     || (srvRecordAge < upDownP->ageOfYoungestRecord))
433                     upDownP->ageOfYoungestRecord = srvRecordAge;
434                 if ((upDownP->ageOfOldestRecord == 0)
435                     || (srvRecordAge > upDownP->ageOfOldestRecord))
436                     upDownP->ageOfOldestRecord = srvRecordAge;
437
438                 if (currSrvP->numDowntimeIncidents <=
439                     AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET0)
440                     (upDownP->downIncidents[0])++;
441                 else if (currSrvP->numDowntimeIncidents <=
442                          AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET1)
443                     (upDownP->downIncidents[1])++;
444                 else if (currSrvP->numDowntimeIncidents <=
445                          AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET2)
446                     (upDownP->downIncidents[2])++;
447                 else if (currSrvP->numDowntimeIncidents <=
448                          AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET3)
449                     (upDownP->downIncidents[3])++;
450                 else if (currSrvP->numDowntimeIncidents <=
451                          AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET4)
452                     (upDownP->downIncidents[4])++;
453                 else
454                     (upDownP->downIncidents[5])++;
455
456
457             }                   /*Current server has been active */
458         }                       /*Walk this chain */
459
460         /*
461          * Before advancing to the next chain, remember facts about this one.
462          */
463         if (currChainLen > afs_stats_cmperf.srvMaxChainLength) {
464             /*
465              * We beat out the former champion (which was initially set to 0
466              * here).  Mark down the new winner, and also remember if it's an
467              * all-time winner.
468              */
469             afs_stats_cmperf.srvMaxChainLength = currChainLen;
470             if (currChainLen > afs_stats_cmperf.srvMaxChainLengthHWM)
471                 afs_stats_cmperf.srvMaxChainLengthHWM = currChainLen;
472         }                       /*Update chain length maximum */
473     }                           /*For each hash chain */
474
475     /*
476      * We're done.  Unlock the server table before returning to our caller.
477      */
478     ReleaseReadLock(&afs_xserver);
479
480 }                               /*afs_CountServers */
481
482
483 void
484 ForceAllNewConnections(void)
485 {
486     int srvAddrCount;
487     struct srvAddr **addrs;
488     struct srvAddr *sa;
489     afs_int32 i, j;
490
491     ObtainReadLock(&afs_xserver);       /* Necessary? */
492     ObtainReadLock(&afs_xsrvAddr);
493
494     srvAddrCount = 0;
495     for (i = 0; i < NSERVERS; i++) {
496         for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
497             srvAddrCount++;
498         }
499     }
500
501     addrs = afs_osi_Alloc(srvAddrCount * sizeof(*addrs));
502     osi_Assert(addrs != NULL);
503     j = 0;
504     for (i = 0; i < NSERVERS; i++) {
505         for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
506             if (j >= srvAddrCount)
507                 break;
508             addrs[j++] = sa;
509         }
510     }
511
512     ReleaseReadLock(&afs_xsrvAddr);
513     ReleaseReadLock(&afs_xserver);
514     for (i = 0; i < j; i++) {
515         sa = addrs[i];
516         ForceNewConnections(sa);
517     }
518
519     afs_osi_Free(addrs, srvAddrCount * sizeof(*addrs));
520 }
521
522 static void
523 CkSrv_MarkUpDown(struct afs_conn **conns, struct rx_connection **rxconns,
524                  int nconns, afs_int32 *results)
525 {
526     struct srvAddr *sa;
527     struct afs_conn *tc;
528     afs_int32 i;
529
530     for(i = 0; i < nconns; i++){
531         tc = conns[i];
532         sa = tc->parent->srvr;
533
534         if (( results[i] >= 0 ) && (sa->sa_flags & SRVADDR_ISDOWN) &&
535             (tc->parent->srvr == sa)) {
536             /* server back up */
537             print_internet_address("afs: file server ", sa, " is back up", 2,
538                                    results[i], rxconns[i]);
539
540             ObtainWriteLock(&afs_xserver, 244);
541             ObtainWriteLock(&afs_xsrvAddr, 245);
542             afs_MarkServerUpOrDown(sa, 0);
543             ReleaseWriteLock(&afs_xsrvAddr);
544             ReleaseWriteLock(&afs_xserver);
545
546             if (afs_waitForeverCount) {
547                 afs_osi_Wakeup(&afs_waitForever);
548             }
549         } else {
550             if (results[i] < 0) {
551                 /* server crashed */
552                 afs_ServerDown(sa, results[i], rxconns[i]);
553                 ForceNewConnections(sa);  /* multi homed clients */
554             }
555         }
556     }
557 }
558
559 void
560 CkSrv_GetCaps(int nconns, struct rx_connection **rxconns,
561               struct afs_conn **conns)
562 {
563     Capabilities *caps;
564     afs_int32 *results;
565     afs_int32 i;
566     struct server *ts;
567
568     caps = afs_osi_Alloc(nconns * sizeof (Capabilities));
569     osi_Assert(caps != NULL);
570     memset(caps, 0, nconns * sizeof(Capabilities));
571
572     results = afs_osi_Alloc(nconns * sizeof (afs_int32));
573     osi_Assert(results != NULL);
574
575     AFS_GUNLOCK();
576     multi_Rx(rxconns,nconns)
577       {
578         multi_RXAFS_GetCapabilities(&caps[multi_i]);
579         results[multi_i] = multi_error;
580       } multi_End;
581     AFS_GLOCK();
582
583     for ( i = 0 ; i < nconns ; i++ ) {
584         ts = conns[i]->parent->srvr->server;
585         if ( !ts )
586             continue;
587         ts->capabilities = 0;
588         ts->flags |= SCAPS_KNOWN;
589         if ( results[i] == RXGEN_OPCODE ) {
590             /* Mark server as up - it responded */
591             results[i] = 0;
592             continue;
593         }
594         if ( results[i] >= 0 )
595             /* we currently handle 32-bits of capabilities */
596             if (caps[i].Capabilities_len > 0) {
597                 ts->capabilities = caps[i].Capabilities_val[0];
598                 xdr_free((xdrproc_t)xdr_Capabilities, &caps[i]);
599                 caps[i].Capabilities_val = NULL;
600                 caps[i].Capabilities_len = 0;
601             }
602     }
603     CkSrv_MarkUpDown(conns, rxconns, nconns, results);
604
605     afs_osi_Free(caps, nconns * sizeof(Capabilities));
606     afs_osi_Free(results, nconns * sizeof(afs_int32));
607 }
608
609 /* check down servers (if adown), or running servers (if !adown) */
610 void
611 afs_CheckServers(int adown, struct cell *acellp)
612 {
613     afs_LoopServers(adown?AFS_LS_DOWN:AFS_LS_UP, acellp, 1, CkSrv_GetCaps, NULL);
614 }
615
616 /* adown: AFS_LS_UP   - check only up
617  *        AFS_LS_DOWN - check only down.
618  *        AFS_LS_ALL  - check all */
619 void
620 afs_LoopServers(int adown, struct cell *acellp, int vlalso,
621                 void (*func1) (int nservers, struct rx_connection **rxconns,
622                                struct afs_conn **conns),
623                 void (*func2) (int nservers, struct rx_connection **rxconns,
624                                struct afs_conn **conns))
625 {
626     struct vrequest *treq = NULL;
627     struct server *ts;
628     struct srvAddr *sa;
629     struct afs_conn *tc = NULL;
630     afs_int32 i, j;
631     afs_int32 code;
632     struct unixuser *tu;
633     int srvAddrCount;
634     struct srvAddr **addrs;
635     struct afs_conn **conns;
636     int nconns;
637     struct rx_connection **rxconns;
638     afs_int32 *conntimer;
639
640     AFS_STATCNT(afs_CheckServers);
641
642     /*
643      * No sense in doing the server checks if we are running in disconnected
644      * mode
645      */
646     if (AFS_IS_DISCONNECTED)
647         return;
648
649     if ((code = afs_CreateReq(&treq, afs_osi_credp)))
650         return;
651     ObtainReadLock(&afs_xserver);       /* Necessary? */
652     ObtainReadLock(&afs_xsrvAddr);
653
654     srvAddrCount = 0;
655     for (i = 0; i < NSERVERS; i++) {
656         for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
657             srvAddrCount++;
658         }
659     }
660
661     addrs = afs_osi_Alloc(srvAddrCount * sizeof(*addrs));
662     osi_Assert(addrs != NULL);
663     j = 0;
664     for (i = 0; i < NSERVERS; i++) {
665         for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
666             if (j >= srvAddrCount)
667                 break;
668             addrs[j++] = sa;
669         }
670     }
671
672     ReleaseReadLock(&afs_xsrvAddr);
673     ReleaseReadLock(&afs_xserver);
674
675     conns = afs_osi_Alloc(j * sizeof(struct afs_conn *));
676     osi_Assert(conns != NULL);
677     rxconns = afs_osi_Alloc(j * sizeof(struct rx_connection *));
678     osi_Assert(rxconns != NULL);
679     conntimer = afs_osi_Alloc(j * sizeof (afs_int32));
680     osi_Assert(conntimer != NULL);
681
682     nconns = 0;
683     for (i = 0; i < j; i++) {
684         struct rx_connection *rxconn;
685         sa = addrs[i];
686         ts = sa->server;
687         if (!ts)
688             continue;
689
690         /* See if a cell to check was specified.  If it is spec'd and not
691          * this server's cell, just skip the server.
692          */
693         if (acellp && acellp != ts->cell)
694             continue;
695
696         if (((adown==AFS_LS_DOWN) && !(sa->sa_flags & SRVADDR_ISDOWN))
697             || ((adown==AFS_LS_UP) && (sa->sa_flags & SRVADDR_ISDOWN)))
698             continue;
699
700         /* check vlserver with special code */
701         if (sa->sa_portal == AFS_VLPORT) {
702             if (vlalso)
703                 CheckVLServer(sa, treq);
704             continue;
705         }
706
707         if (!ts->cell)          /* not really an active server, anyway, it must */
708             continue;           /* have just been added by setsprefs */
709
710         /* get a connection, even if host is down; bumps conn ref count */
711         tu = afs_GetUser(treq->uid, ts->cell->cellNum, SHARED_LOCK);
712         tc = afs_ConnBySA(sa, ts->cell->fsport, ts->cell->cellNum, tu,
713                           1 /*force */ , 1 /*create */ , SHARED_LOCK, 0,
714                           &rxconn);
715         afs_PutUser(tu, SHARED_LOCK);
716         if (!tc)
717             continue;
718
719         if ((sa->sa_flags & SRVADDR_ISDOWN) || afs_HaveCallBacksFrom(sa->server)) {
720             conns[nconns]=tc;
721             rxconns[nconns]=rxconn;
722             if (sa->sa_flags & SRVADDR_ISDOWN) {
723                 rx_SetConnDeadTime(rxconn, 3);
724                 conntimer[nconns]=1;
725             } else {
726                 conntimer[nconns]=0;
727             }
728             nconns++;
729         } else /* not holding, kill ref */
730             afs_PutConn(tc, rxconn, SHARED_LOCK);
731     } /* Outer loop over addrs */
732
733     afs_osi_Free(addrs, srvAddrCount * sizeof(*addrs));
734     addrs = NULL;
735
736     (*func1)(nconns, rxconns, conns);
737
738     if (func2) {
739         (*func2)(nconns, rxconns, conns);
740     }
741
742     for (i = 0; i < nconns; i++) {
743         if (conntimer[i] == 1)
744             rx_SetConnDeadTime(rxconns[i], afs_rx_deadtime);
745         afs_PutConn(conns[i], rxconns[i], SHARED_LOCK);     /* done with it now */
746     }
747
748     afs_osi_Free(conns, j * sizeof(struct afs_conn *));
749     afs_osi_Free(rxconns, j * sizeof(struct rx_connection *));
750     afs_osi_Free(conntimer, j * sizeof(afs_int32));
751     afs_DestroyReq(treq);
752
753 } /*afs_CheckServers*/
754
755
756 /* find a server structure given the host address */
757 struct server *
758 afs_FindServer(afs_int32 aserver, afs_uint16 aport, afsUUID * uuidp,
759                afs_int32 locktype)
760 {
761     struct server *ts;
762     struct srvAddr *sa;
763     int i;
764
765     AFS_STATCNT(afs_FindServer);
766     if (uuidp) {
767         i = afs_uuid_hash(uuidp) % NSERVERS;
768         for (ts = afs_servers[i]; ts; ts = ts->next) {
769             if ((ts->flags & SRVR_MULTIHOMED)
770                 &&
771                 (memcmp((char *)uuidp, (char *)&ts->sr_uuid, sizeof(*uuidp))
772                  == 0) && (!ts->addr || (ts->addr->sa_portal == aport)))
773                 return ts;
774         }
775     } else {
776         i = SHash(aserver);
777         for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
778             if ((sa->sa_ip == aserver) && (sa->sa_portal == aport)) {
779                 return sa->server;
780             }
781         }
782     }
783     return NULL;
784
785 }                               /*afs_FindServer */
786
787
788 /* some code for creating new server structs and setting preferences follows
789  * in the next few lines...
790  */
791
792 #define MAXDEFRANK 60000
793 #define DEFRANK    40000
794
795 /* Random number generator and constants from KnuthV2 2d ed, p170 */
796
797 /* Rules:
798    X = (aX + c) % m
799    m is a power of two
800    a % 8 is 5
801    a is 0.73m  should be 0.01m .. 0.99m
802    c is more or less immaterial.  1 or a is suggested.
803
804 NB:  LOW ORDER BITS are not very random.  To get small random numbers,
805      treat result as <1, with implied binary point, and multiply by
806      desired modulus.
807 NB:  Has to be unsigned, since shifts on signed quantities may preserve
808      the sign bit.
809 */
810 /* added rxi_getaddr() to try to get as much initial randomness as
811    possible, since at least one customer reboots ALL their clients
812    simultaneously -- so osi_Time is bound to be the same on some of the
813    clients.  This is probably OK, but I don't want to see too much of it.
814 */
815
816 #define ranstage(x)     (x)= (afs_uint32) (3141592621U*((afs_uint32)x)+1)
817
818 unsigned int
819 afs_random(void)
820 {
821     static afs_int32 state = 0;
822     int i;
823
824     AFS_STATCNT(afs_random);
825     if (!state) {
826         osi_timeval32_t t;
827         osi_GetTime(&t);
828         /*
829          * Clear the low nybble of tv_usec in a size-independent manner before adding
830          * in the rest of the state.
831          */
832         state = t.tv_usec;
833         state ^= (state & 0x0f);
834         state += rxi_getaddr() & 0xff;
835         state += (t.tv_sec & 0xff);
836         for (i = 0; i < 30; i++) {
837             ranstage(state);
838         }
839     }
840
841     ranstage(state);
842     return (state);
843
844 }                               /*afs_random */
845
846 /* returns int 0..14 using the high bits of a pseudo-random number instead of
847    the low bits, as the low bits are "less random" than the high ones...
848    slight roundoff error exists, an excercise for the reader.
849    need to multiply by something with lots of ones in it, so multiply by
850    8 or 16 is right out.
851  */
852 int
853 afs_randomMod15(void)
854 {
855     afs_uint32 temp;
856
857     temp = afs_random() >> 4;
858     temp = (temp * 15) >> 28;
859
860     return temp;
861 }
862
863 int
864 afs_randomMod127(void)
865 {
866     afs_uint32 temp;
867
868     temp = afs_random() >> 7;
869     temp = (temp * 127) >> 25;
870
871     return temp;
872 }
873
874 /* afs_SortOneServer()
875  * Sort all of the srvAddrs, of a server struct, by rank from low to high.
876  */
877 void
878 afs_SortOneServer(struct server *asp)
879 {
880     struct srvAddr **rootsa, *lowsa, *tsa, *lowprev;
881     int lowrank, rank;
882
883     for (rootsa = &(asp->addr); *rootsa; rootsa = &(lowsa->next_sa)) {
884         lowprev = NULL;
885         lowsa = *rootsa;        /* lowest sa is the first one */
886         lowrank = lowsa->sa_iprank;
887
888         for (tsa = *rootsa; tsa->next_sa; tsa = tsa->next_sa) {
889             rank = tsa->next_sa->sa_iprank;
890             if (rank < lowrank) {
891                 lowprev = tsa;
892                 lowsa = tsa->next_sa;
893                 lowrank = lowsa->sa_iprank;
894             }
895         }
896         if (lowprev) {          /* found one lower, so rearrange them */
897             lowprev->next_sa = lowsa->next_sa;
898             lowsa->next_sa = *rootsa;
899             *rootsa = lowsa;
900         }
901     }
902 }
903
904 /* afs_SortServer()
905  * Sort the pointer to servers by the server's rank (its lowest rank).
906  * It is assumed that the server already has its IP addrs sorted (the
907  * first being its lowest rank: afs_GetServer() calls afs_SortOneServer()).
908  */
909 void
910 afs_SortServers(struct server *aservers[], int count)
911 {
912     struct server *ts;
913     int i, j, low;
914
915     AFS_STATCNT(afs_SortServers);
916
917     for (i = 0; i < count; i++) {
918         if (!aservers[i])
919             break;
920         for (low = i, j = i + 1; j <= count; j++) {
921             if ((!aservers[j]) || (!aservers[j]->addr))
922                 break;
923             if ((!aservers[low]) || (!aservers[low]->addr))
924                 break;
925             if (aservers[j]->addr->sa_iprank < aservers[low]->addr->sa_iprank) {
926                 low = j;
927             }
928         }
929         if (low != i) {
930             ts = aservers[i];
931             aservers[i] = aservers[low];
932             aservers[low] = ts;
933         }
934     }
935 }                               /*afs_SortServers */
936
937 /* afs_SetServerPrefs is rather system-dependent.  It pokes around in kernel
938    data structures to determine what the local IP addresses and subnet masks
939    are in order to choose which server(s) are on the local subnet.
940
941    As I see it, there are several cases:
942    1. The server address is one of this host's local addresses.  In this case
943           this server is to be preferred over all others.
944    2. The server is on the same subnet as one of the this host's local
945       addresses.  (ie, an odd-sized subnet, not class A,B,orC)
946    3. The server is on the same net as this host (class A,B or C)
947    4. The server is on a different logical subnet or net than this host, but
948    this host is a 'metric 0 gateway' to it.  Ie, two address-spaces share
949    one physical medium.
950    5. This host has a direct (point-to-point, ie, PPP or SLIP) link to the
951    server.
952    6. This host and the server are disjoint.
953
954    That is a rough order of preference.  If a point-to-point link has a high
955    metric, I'm assuming that it is a very slow link, and putting it at the
956    bottom of the list (at least until RX works better over slow links).  If
957    its metric is 1, I'm assuming that it's relatively fast (T1) and putting
958    it ahead of #6.
959    It's not easy to check for case #4, so I'm ignoring it for the time being.
960
961    BSD "if" code keeps track of some rough network statistics (cf 'netstat -i')
962    That could be used to prefer certain servers fairly easily.  Maybe some
963    other time...
964
965    NOTE: this code is very system-dependent, and very dependent on the TCP/IP
966    protocols (well, addresses that are stored in uint32s, at any rate).
967  */
968
969 #define IA_DST(ia)((struct sockaddr_in *)(&((struct in_ifaddr *)ia)->ia_dstaddr))
970 #define IA_BROAD(ia)((struct sockaddr_in *)(&((struct in_ifaddr *)ia)->ia_broadaddr))
971
972 /* SA2ULONG takes a sockaddr_in, not a sockaddr (same thing, just cast it!) */
973 #define SA2ULONG(sa) ((sa)->sin_addr.s_addr)
974 #define TOPR 5000
975 #define HI  20000
976 #define MED 30000
977 #define LO DEFRANK
978 #define PPWEIGHT 4096
979
980 #define USEIFADDR
981
982 #ifdef AFS_USERSPACE_IP_ADDR
983 #ifndef afs_min
984 #define afs_min(A,B) ((A)<(B)) ? (A) : (B)
985 #endif
986 /*
987  * The IP addresses and ranks are determined by afsd (in user space) and
988  * passed into the kernel at startup time through the AFSOP_ADVISEADDR
989  * system call. These are stored in the data structure
990  * called 'afs_cb_interface'.
991  *
992  * struct srvAddr *sa;         remote server
993  * afs_int32 addr;                one of my local addr in net order
994  * afs_uint32 subnetmask;         subnet mask of local addr in net order
995  *
996  */
997 void
998 afsi_SetServerIPRank(struct srvAddr *sa, afs_int32 addr,
999                      afs_uint32 subnetmask)
1000 {
1001     afs_uint32 myAddr, myNet, mySubnet, netMask;
1002     afs_uint32 serverAddr;
1003
1004     myAddr = ntohl(addr);       /* one of my IP addr in host order */
1005     serverAddr = ntohl(sa->sa_ip);      /* server's IP addr in host order */
1006     subnetmask = ntohl(subnetmask);     /* subnet mask in host order */
1007
1008     if (IN_CLASSA(myAddr))
1009         netMask = IN_CLASSA_NET;
1010     else if (IN_CLASSB(myAddr))
1011         netMask = IN_CLASSB_NET;
1012     else if (IN_CLASSC(myAddr))
1013         netMask = IN_CLASSC_NET;
1014     else
1015         netMask = 0;
1016
1017     myNet = myAddr & netMask;
1018     mySubnet = myAddr & subnetmask;
1019
1020     if ((serverAddr & netMask) == myNet) {
1021         if ((serverAddr & subnetmask) == mySubnet) {
1022             if (serverAddr == myAddr) { /* same machine */
1023                 sa->sa_iprank = afs_min(sa->sa_iprank, TOPR);
1024             } else {            /* same subnet */
1025                 sa->sa_iprank = afs_min(sa->sa_iprank, HI);
1026             }
1027         } else {                /* same net */
1028             sa->sa_iprank = afs_min(sa->sa_iprank, MED);
1029         }
1030     }
1031     return;
1032 }
1033 #else /* AFS_USERSPACE_IP_ADDR */
1034 #if (! defined(AFS_SUN5_ENV)) && (! defined(AFS_DARWIN_ENV)) && (! defined(AFS_OBSD47_ENV)) && (! defined(AFS_FBSD_ENV)) && defined(USEIFADDR)
1035 void
1036 afsi_SetServerIPRank(struct srvAddr *sa, struct in_ifaddr *ifa)
1037 {
1038     struct sockaddr_in *sin;
1039     int t;
1040
1041     if ((ntohl(sa->sa_ip) & ifa->ia_netmask) == ifa->ia_net) {
1042         if ((ntohl(sa->sa_ip) & ifa->ia_subnetmask) == ifa->ia_subnet) {
1043             sin = IA_SIN(ifa);
1044             if (SA2ULONG(sin) == ntohl(sa->sa_ip)) {    /* ie, ME!!!  */
1045                 sa->sa_iprank = TOPR;
1046             } else {
1047                 t = HI + ifa->ia_ifp->if_metric;        /* case #2 */
1048                 if (sa->sa_iprank > t)
1049                     sa->sa_iprank = t;
1050             }
1051         } else {
1052             t = MED + ifa->ia_ifp->if_metric;   /* case #3 */
1053             if (sa->sa_iprank > t)
1054                 sa->sa_iprank = t;
1055         }
1056     }
1057 #if defined(IFF_POINTOPOINT) && !defined(UKERNEL)
1058     /* check for case #4 -- point-to-point link */
1059     if ((ifa->ia_ifp->if_flags & IFF_POINTOPOINT)
1060         && (SA2ULONG(IA_DST(ifa)) == ntohl(sa->sa_ip))) {
1061         if (ifa->ia_ifp->if_metric >= (MAXDEFRANK - MED) / PPWEIGHT)
1062             t = MAXDEFRANK;
1063         else
1064             t = MED + (PPWEIGHT << ifa->ia_ifp->if_metric);
1065         if (sa->sa_iprank > t)
1066             sa->sa_iprank = t;
1067     }
1068 #endif /* IFF_POINTOPOINT */
1069 }
1070 #endif /*(!defined(AFS_SUN5_ENV)) && defined(USEIFADDR) */
1071 #if (defined(AFS_DARWIN_ENV) || defined(AFS_OBSD47_ENV) || defined(AFS_FBSD_ENV)) && defined(USEIFADDR)
1072 #ifndef afs_min
1073 #define afs_min(A,B) ((A)<(B)) ? (A) : (B)
1074 #endif
1075 void
1076 afsi_SetServerIPRank(struct srvAddr *sa, rx_ifaddr_t ifa)
1077 {
1078     struct sockaddr sout;
1079     struct sockaddr_in *sin;
1080 #if defined(AFS_DARWIN80_ENV) && !defined(UKERNEL)
1081     int t;
1082 #else
1083     void *t;
1084 #endif
1085
1086     afs_uint32 subnetmask, myAddr, myNet, myDstaddr, mySubnet, netMask;
1087     afs_uint32 serverAddr;
1088
1089     if (rx_ifaddr_address_family(ifa) != AF_INET)
1090         return;
1091     t = rx_ifaddr_address(ifa, &sout, sizeof(sout));
1092     if (t != 0) {
1093         sin = (struct sockaddr_in *)&sout;
1094         myAddr = ntohl(sin->sin_addr.s_addr);   /* one of my IP addr in host order */
1095     } else {
1096         myAddr = 0;
1097     }
1098     serverAddr = ntohl(sa->sa_ip);      /* server's IP addr in host order */
1099     t = rx_ifaddr_netmask(ifa, &sout, sizeof(sout));
1100     if (t != 0) {
1101         sin = (struct sockaddr_in *)&sout;
1102         subnetmask = ntohl(sin->sin_addr.s_addr);       /* subnet mask in host order */
1103     } else {
1104         subnetmask = 0;
1105     }
1106     t = rx_ifaddr_dstaddress(ifa, &sout, sizeof(sout));
1107     if (t != 0) {
1108         sin = (struct sockaddr_in *)&sout;
1109         myDstaddr = ntohl(sin->sin_addr.s_addr);
1110     } else {
1111         myDstaddr = 0;
1112     }
1113
1114     if (IN_CLASSA(myAddr))
1115         netMask = IN_CLASSA_NET;
1116     else if (IN_CLASSB(myAddr))
1117         netMask = IN_CLASSB_NET;
1118     else if (IN_CLASSC(myAddr))
1119         netMask = IN_CLASSC_NET;
1120     else
1121         netMask = 0;
1122
1123     myNet = myAddr & netMask;
1124     mySubnet = myAddr & subnetmask;
1125
1126     if ((serverAddr & netMask) == myNet) {
1127         if ((serverAddr & subnetmask) == mySubnet) {
1128             if (serverAddr == myAddr) { /* same machine */
1129                 sa->sa_iprank = afs_min(sa->sa_iprank, TOPR);
1130             } else {            /* same subnet */
1131                 sa->sa_iprank = afs_min(sa->sa_iprank, HI + rx_ifnet_metric(rx_ifaddr_ifnet(ifa)));
1132             }
1133         } else {                /* same net */
1134             sa->sa_iprank = afs_min(sa->sa_iprank, MED + rx_ifnet_metric(rx_ifaddr_ifnet(ifa)));
1135         }
1136     }
1137 #ifdef  IFF_POINTTOPOINT
1138     /* check for case #4 -- point-to-point link */
1139     if ((rx_ifnet_flags(rx_ifaddr_ifnet(ifa)) & IFF_POINTOPOINT)
1140         && (myDstaddr == serverAddr)) {
1141         if (rx_ifnet_metric(rx_ifaddr_ifnet(ifa)) >= (MAXDEFRANK - MED) / PPWEIGHT)
1142             t = MAXDEFRANK;
1143         else
1144             t = MED + (PPWEIGHT << rx_ifnet_metric(rx_ifaddr_ifnet(ifa)));
1145         if (sa->sa_iprank > t)
1146             sa->sa_iprank = t;
1147         }
1148 #endif /* IFF_POINTTOPOINT */
1149 }
1150 #endif /*(!defined(AFS_SUN5_ENV)) && defined(USEIFADDR) */
1151 #endif /* else AFS_USERSPACE_IP_ADDR */
1152
1153 #ifdef AFS_SGI62_ENV
1154 static int
1155 afsi_enum_set_rank(struct hashbucket *h, caddr_t mkey, caddr_t arg1,
1156                    caddr_t arg2)
1157 {
1158     afsi_SetServerIPRank((struct srvAddr *)arg1, (struct in_ifaddr *)h);
1159     return 0;                   /* Never match, so we enumerate everyone */
1160 }
1161 #endif                          /* AFS_SGI62_ENV */
1162 static int
1163 afs_SetServerPrefs(struct srvAddr *const sa)
1164 {
1165 #if     defined(AFS_USERSPACE_IP_ADDR)
1166     int i;
1167
1168       sa->sa_iprank = LO;
1169     for (i = 0; i < afs_cb_interface.numberOfInterfaces; i++) {
1170         afsi_SetServerIPRank(sa, afs_cb_interface.addr_in[i],
1171                              afs_cb_interface.subnetmask[i]);
1172     }
1173 #else                           /* AFS_USERSPACE_IP_ADDR */
1174 #if     defined(AFS_SUN5_ENV)
1175 #ifdef AFS_SUN510_ENV
1176     int i = 0;
1177 #else
1178     extern struct ill_s *ill_g_headp;
1179     long *addr = (long *)ill_g_headp;
1180     ill_t *ill;
1181     ipif_t *ipif;
1182 #endif
1183     int subnet, subnetmask, net, netmask;
1184
1185     sa->sa_iprank = 0;
1186 #ifdef AFS_SUN510_ENV
1187     rw_enter(&afsifinfo_lock, RW_READER);
1188
1189     for (i = 0; (afsifinfo[i].ipaddr != NULL) && (i < ADDRSPERSITE); i++) {
1190
1191         if (IN_CLASSA(afsifinfo[i].ipaddr)) {
1192             netmask = IN_CLASSA_NET;
1193         } else if (IN_CLASSB(afsifinfo[i].ipaddr)) {
1194             netmask = IN_CLASSB_NET;
1195         } else if (IN_CLASSC(afsifinfo[i].ipaddr)) {
1196             netmask = IN_CLASSC_NET;
1197         } else {
1198             netmask = 0;
1199         }
1200         net = afsifinfo[i].ipaddr & netmask;
1201
1202         {
1203             /* XXXXXX Do the individual ip ranking below XXXXX */
1204             if ((sa->sa_ip & netmask) == net) {
1205                 if ((sa->sa_ip & subnetmask) == subnet) {
1206                     if (afsifinfo[i].ipaddr == sa->sa_ip) {   /* ie, ME!  */
1207                         sa->sa_iprank = TOPR;
1208                     } else {
1209                         sa->sa_iprank = HI + afsifinfo[i].metric; /* case #2 */
1210                     }
1211                 } else {
1212                     sa->sa_iprank = MED + afsifinfo[i].metric;    /* case #3 */
1213                 }
1214             } else {
1215                     sa->sa_iprank = LO + afsifinfo[i].metric;     /* case #4 */
1216             }
1217             /* check for case #5 -- point-to-point link */
1218             if ((afsifinfo[i].flags & IFF_POINTOPOINT)
1219                 && (afsifinfo[i].dstaddr == sa->sa_ip)) {
1220
1221                     if (afsifinfo[i].metric >= (MAXDEFRANK - MED) / PPWEIGHT)
1222                         sa->sa_iprank = MAXDEFRANK;
1223                     else
1224                         sa->sa_iprank = MED + (PPWEIGHT << afsifinfo[i].metric);
1225             }
1226         }
1227     }
1228
1229     rw_exit(&afsifinfo_lock);
1230 #else
1231     for (ill = (struct ill_s *)*addr /*ill_g_headp */ ; ill;
1232          ill = ill->ill_next) {
1233         /* Make sure this is an IPv4 ILL */
1234         if (ill->ill_isv6)
1235             continue;
1236         for (ipif = ill->ill_ipif; ipif; ipif = ipif->ipif_next) {
1237             subnet = ipif->ipif_local_addr & ipif->ipif_net_mask;
1238             subnetmask = ipif->ipif_net_mask;
1239             /*
1240              * Generate the local net using the local address and
1241              * whate we know about Class A, B and C networks.
1242              */
1243             if (IN_CLASSA(ipif->ipif_local_addr)) {
1244                 netmask = IN_CLASSA_NET;
1245             } else if (IN_CLASSB(ipif->ipif_local_addr)) {
1246                 netmask = IN_CLASSB_NET;
1247             } else if (IN_CLASSC(ipif->ipif_local_addr)) {
1248                 netmask = IN_CLASSC_NET;
1249             } else {
1250                 netmask = 0;
1251             }
1252             net = ipif->ipif_local_addr & netmask;
1253             {
1254                 /* XXXXXX Do the individual ip ranking below XXXXX */
1255                 if ((sa->sa_ip & netmask) == net) {
1256                     if ((sa->sa_ip & subnetmask) == subnet) {
1257                         if (ipif->ipif_local_addr == sa->sa_ip) {       /* ie, ME!  */
1258                             sa->sa_iprank = TOPR;
1259                         } else {
1260                             sa->sa_iprank = HI + ipif->ipif_metric;     /* case #2 */
1261                         }
1262                     } else {
1263                         sa->sa_iprank = MED + ipif->ipif_metric;        /* case #3 */
1264                     }
1265                 } else {
1266                     sa->sa_iprank = LO + ipif->ipif_metric;     /* case #4 */
1267                 }
1268                 /* check for case #5 -- point-to-point link */
1269                 if ((ipif->ipif_flags & IFF_POINTOPOINT)
1270                     && (ipif->ipif_pp_dst_addr == sa->sa_ip)) {
1271
1272                     if (ipif->ipif_metric >= (MAXDEFRANK - MED) / PPWEIGHT)
1273                         sa->sa_iprank = MAXDEFRANK;
1274                     else
1275                         sa->sa_iprank = MED + (PPWEIGHT << ipif->ipif_metric);
1276                 }
1277             }
1278         }
1279     }
1280 #endif /* AFS_SUN510_ENV */
1281 #else
1282 #ifndef USEIFADDR
1283     rx_ifnet_t ifn = NULL;
1284     struct in_ifaddr *ifad = (struct in_ifaddr *)0;
1285     struct sockaddr_in *sin;
1286
1287     sa->sa_iprank = 0;
1288     ifn = rxi_FindIfnet(sa->sa_ip, &ifad);
1289     if (ifn) {                  /* local, more or less */
1290 #ifdef IFF_LOOPBACK
1291         if (ifn->if_flags & IFF_LOOPBACK) {
1292             sa->sa_iprank = TOPR;
1293             goto end;
1294         }
1295 #endif /* IFF_LOOPBACK */
1296         sin = (struct sockaddr_in *)IA_SIN(ifad);
1297         if (SA2ULONG(sin) == sa->sa_ip) {
1298             sa->sa_iprank = TOPR;
1299             goto end;
1300         }
1301 #ifdef IFF_BROADCAST
1302         if (ifn->if_flags & IFF_BROADCAST) {
1303             if (sa->sa_ip == (sa->sa_ip & SA2ULONG(IA_BROAD(ifad)))) {
1304                 sa->sa_iprank = HI;
1305                 goto end;
1306             }
1307         }
1308 #endif /* IFF_BROADCAST */
1309 #ifdef IFF_POINTOPOINT
1310         if (ifn->if_flags & IFF_POINTOPOINT) {
1311             if (sa->sa_ip == SA2ULONG(IA_DST(ifad))) {
1312                 if (ifn->if_metric > 4) {
1313                     sa->sa_iprank = LO;
1314                     goto end;
1315                 } else
1316                     sa->sa_iprank = ifn->if_metric;
1317             }
1318         }
1319 #endif /* IFF_POINTOPOINT */
1320         sa->sa_iprank += MED + ifn->if_metric;  /* couldn't find anything better */
1321     }
1322 #else                           /* USEIFADDR */
1323
1324     sa->sa_iprank = LO;
1325 #ifdef AFS_SGI62_ENV
1326     (void)hash_enum(&hashinfo_inaddr, afsi_enum_set_rank, HTF_INET, NULL,
1327                     (caddr_t) sa, NULL);
1328 #elif defined(AFS_DARWIN80_ENV)
1329     {
1330         errno_t t;
1331         unsigned int count;
1332         int cnt=0, m, j;
1333         rx_ifaddr_t *ifads;
1334         rx_ifnet_t *ifns;
1335
1336         if (!ifnet_list_get(AF_INET, &ifns, &count)) {
1337             for (m = 0; m < count; m++) {
1338                 if (!ifnet_get_address_list(ifns[m], &ifads)) {
1339                     for (j = 0; ifads[j] != NULL && cnt < ADDRSPERSITE; j++) {
1340                         afsi_SetServerIPRank(sa, ifads[j]);
1341                         cnt++;
1342                     }
1343                     ifnet_free_address_list(ifads);
1344                 }
1345             }
1346             ifnet_list_free(ifns);
1347         }
1348     }
1349 #elif defined(AFS_DARWIN_ENV)
1350     {
1351         rx_ifnet_t ifn;
1352         rx_ifaddr_t ifa;
1353           TAILQ_FOREACH(ifn, &ifnet, if_link) {
1354             TAILQ_FOREACH(ifa, &ifn->if_addrhead, ifa_link) {
1355                 afsi_SetServerIPRank(sa, ifa);
1356     }}}
1357 #elif defined(AFS_FBSD_ENV)
1358     {
1359         struct in_ifaddr *ifa;
1360         CURVNET_SET(rx_socket->so_vnet);
1361         TAILQ_FOREACH(ifa, &V_in_ifaddrhead, ia_link) {
1362             afsi_SetServerIPRank(sa, &ifa->ia_ifa);
1363         }
1364         CURVNET_RESTORE();
1365     }
1366 #elif defined(AFS_OBSD_ENV)
1367     {
1368         extern struct in_ifaddrhead in_ifaddr;
1369         struct in_ifaddr *ifa;
1370         for (ifa = in_ifaddr.tqh_first; ifa; ifa = ifa->ia_list.tqe_next)
1371             afsi_SetServerIPRank(sa, ifa);
1372     }
1373 #elif defined(AFS_NBSD40_ENV)
1374      {
1375        extern struct in_ifaddrhead in_ifaddrhead;
1376        struct in_ifaddr *ifa;
1377        for (ifa = in_ifaddrhead.tqh_first; ifa; ifa = ifa->ia_list.tqe_next)
1378            afsi_SetServerIPRank(sa, ifa);
1379      }
1380 #else
1381     {
1382         struct in_ifaddr *ifa;
1383         for (ifa = in_ifaddr; ifa; ifa = ifa->ia_next) {
1384             afsi_SetServerIPRank(sa, ifa);
1385     }}
1386 #endif
1387 #endif                          /* USEIFADDR */
1388 #ifndef USEIFADDR
1389     end:
1390 #endif
1391 #endif                          /* AFS_SUN5_ENV */
1392 #endif                          /* else AFS_USERSPACE_IP_ADDR */
1393     sa->sa_iprank += afs_randomMod15();
1394
1395     return 0;
1396 }                               /* afs_SetServerPrefs */
1397
1398 #undef TOPR
1399 #undef HI
1400 #undef MED
1401 #undef LO
1402 #undef PPWEIGHT
1403
1404 /* afs_FlushServer()
1405  * The addresses on this server struct has changed in some way and will
1406  * clean up all other structures that may reference it.
1407  * The afs_xserver, afs_xvcb and afs_xsrvAddr locks are assumed taken.
1408  */
1409 static void
1410 afs_FlushServer(struct server *srvp, struct volume *tv)
1411 {
1412     afs_int32 i;
1413     struct server *ts, **pts;
1414
1415     /* Find any volumes residing on this server and flush their state */
1416     afs_ResetVolumes(srvp, tv);
1417
1418     /* Flush all callbacks in the all vcaches for this specific server */
1419     afs_FlushServerCBs(srvp);
1420
1421     /* Remove all the callbacks structs */
1422     if (srvp->cbrs) {
1423         struct afs_cbr *cb, *cbnext;
1424
1425         for (cb = srvp->cbrs; cb; cb = cbnext) {
1426             cbnext = cb->next;
1427             afs_FreeCBR(cb);
1428         } srvp->cbrs = (struct afs_cbr *)0;
1429     }
1430
1431     /* If no more srvAddr structs hanging off of this server struct,
1432      * then clean it up.
1433      */
1434     if (!srvp->addr) {
1435         /* Remove the server structure from the cell list - if there */
1436         afs_RemoveCellEntry(srvp);
1437
1438         /* Remove from the afs_servers hash chain */
1439         for (i = 0; i < NSERVERS; i++) {
1440             for (pts = &(afs_servers[i]), ts = *pts; ts;
1441                  pts = &(ts->next), ts = *pts) {
1442                 if (ts == srvp)
1443                     break;
1444             }
1445             if (ts)
1446                 break;
1447         }
1448         if (ts) {
1449             *pts = ts->next;    /* Found it. Remove it */
1450             afs_osi_Free(ts, sizeof(struct server));    /* Free it */
1451             afs_totalServers--;
1452         }
1453     }
1454 }
1455
1456 /* afs_RemoveSrvAddr()
1457  * This removes a SrvAddr structure from its server structure.
1458  * The srvAddr struct is not free'd because it connections may still
1459  * be open to it. It is up to the calling process to make sure it
1460  * remains connected to a server struct.
1461  * The afs_xserver and afs_xsrvAddr locks are assumed taken.
1462  *    It is not removed from the afs_srvAddrs hash chain.
1463  * If resetting volumes, do not reset volume tv
1464  */
1465 static void
1466 afs_RemoveSrvAddr(struct srvAddr *sap, struct volume *tv)
1467 {
1468     struct srvAddr **psa, *sa;
1469     struct server *srv;
1470
1471     if (!sap)
1472           return;
1473       srv = sap->server;
1474
1475     /* Find the srvAddr in the server's list and remove it */
1476     for (psa = &(srv->addr), sa = *psa; sa; psa = &(sa->next_sa), sa = *psa) {
1477         if (sa == sap)
1478             break;
1479     } if (sa) {
1480         *psa = sa->next_sa;
1481         sa->next_sa = 0;
1482         sa->server = 0;
1483
1484         /* Flush the server struct since it's IP address has changed */
1485         afs_FlushServer(srv, tv);
1486     }
1487 }
1488
1489 /* afs_GetCapabilities
1490  * Try and retrieve capabilities of a given file server. Carps on actual
1491  * failure. Servers are not expected to support this RPC. */
1492 void
1493 afs_GetCapabilities(struct server *ts)
1494 {
1495     Capabilities caps = {0, NULL};
1496     struct vrequest *treq = NULL;
1497     struct afs_conn *tc;
1498     struct unixuser *tu;
1499     struct rx_connection *rxconn;
1500     afs_int32 code;
1501
1502     if ( !ts || !ts->cell )
1503         return;
1504     if ( !afs_osi_credp )
1505         return;
1506
1507     if ((code = afs_CreateReq(&treq, afs_osi_credp)))
1508         return;
1509     tu = afs_GetUser(treq->uid, ts->cell->cellNum, SHARED_LOCK);
1510     if ( !tu ) {
1511         afs_DestroyReq(treq);
1512         return;
1513     }
1514     tc = afs_ConnBySA(ts->addr, ts->cell->fsport, ts->cell->cellNum, tu, 0, 1,
1515                       SHARED_LOCK, 0, &rxconn);
1516     afs_PutUser(tu, SHARED_LOCK);
1517     if ( !tc ) {
1518         afs_DestroyReq(treq);
1519         return;
1520     }
1521     /* InitCallBackStateN, triggered by our RPC, may need this */
1522     ReleaseWriteLock(&afs_xserver);
1523     AFS_GUNLOCK();
1524     code = RXAFS_GetCapabilities(rxconn, &caps);
1525     AFS_GLOCK();
1526     ObtainWriteLock(&afs_xserver, 723);
1527     /* we forced a conn above; important we mark it down if needed */
1528     if ((code < 0) && (code != RXGEN_OPCODE)) {
1529         afs_ServerDown(tc->parent->srvr, code, rxconn);
1530         ForceNewConnections(tc->parent->srvr); /* multi homed clients */
1531     }
1532     afs_PutConn(tc, rxconn, SHARED_LOCK);
1533     if ( code && code != RXGEN_OPCODE ) {
1534         afs_warn("RXAFS_GetCapabilities failed with code %d\n", code);
1535         /* better not be anything to free. we failed! */
1536         afs_DestroyReq(treq);
1537         return;
1538     }
1539
1540     ts->flags |= SCAPS_KNOWN;
1541
1542     if ( caps.Capabilities_len > 0 ) {
1543         ts->capabilities = caps.Capabilities_val[0];
1544         xdr_free((xdrproc_t)xdr_Capabilities, &caps);
1545         caps.Capabilities_len = 0;
1546         caps.Capabilities_val = NULL;
1547     }
1548
1549     afs_DestroyReq(treq);
1550 }
1551
1552 static struct server *
1553 afs_SearchServer(u_short aport, afsUUID * uuidp, afs_int32 locktype,
1554                  struct server **oldts, afs_int32 addr_uniquifier)
1555 {
1556     struct server *ts = afs_FindServer(0, aport, uuidp, locktype);
1557     if (ts && (ts->sr_addr_uniquifier == addr_uniquifier) && ts->addr) {
1558         /* Found a server struct that is multihomed and same
1559          * uniqufier (same IP addrs). The above if statement is the
1560          * same as in InstallUVolumeEntry().
1561          */
1562         return ts;
1563     }
1564     if (ts)
1565         *oldts = ts;            /* Will reuse if same uuid */
1566     return NULL;
1567 }
1568
1569 /*!
1570  * Return an updated and properly initialized server structure.
1571  *
1572  * Takes a server ID, cell, and port.
1573  * If server does not exist, then one will be created.
1574  * @param[in] aserverp
1575  *      The server address in network byte order
1576  * @param[in] nservers
1577  *      The number of IP addresses claimed by the server
1578  * @param[in] acell
1579  *      The cell the server is in
1580  * @param[in] aport
1581  *      The port for the server (fileserver or vlserver) in network byte order
1582  * @param[in] locktype
1583  *      The type of lock to hold when iterating server hash (unused).
1584  * @param[in] uuidp
1585  *      The uuid for servers supporting one.
1586  * @param[in] addr_uniquifier
1587  *      The vldb-provider per-instantiated-server uniquifer counter.
1588  * @param[in] tv
1589  *      A volume not to reset information for if the server addresses
1590  *      changed.
1591  *
1592  * @return
1593  *      A server structure matching the request.
1594  */
1595 struct server *
1596 afs_GetServer(afs_uint32 *aserverp, afs_int32 nservers, afs_int32 acell,
1597               u_short aport, afs_int32 locktype, afsUUID * uuidp,
1598               afs_int32 addr_uniquifier, struct volume *tv)
1599 {
1600     struct server *oldts = 0, *ts, *newts, *orphts = 0;
1601     struct srvAddr *oldsa, *newsa, *nextsa, *orphsa;
1602     afs_int32 iphash, k, srvcount = 0;
1603     unsigned int srvhash;
1604
1605     AFS_STATCNT(afs_GetServer);
1606
1607     ObtainSharedLock(&afs_xserver, 13);
1608
1609     /* Check if the server struct exists and is up to date */
1610     if (!uuidp) {
1611         if (nservers != 1)
1612             panic("afs_GetServer: incorrect count of servers");
1613         ObtainReadLock(&afs_xsrvAddr);
1614         ts = afs_FindServer(aserverp[0], aport, NULL, locktype);
1615         ReleaseReadLock(&afs_xsrvAddr);
1616         if (ts && !(ts->flags & SRVR_MULTIHOMED)) {
1617             /* Found a server struct that is not multihomed and has the
1618              * IP address associated with it. A correct match.
1619              */
1620             ReleaseSharedLock(&afs_xserver);
1621             return (ts);
1622         }
1623     } else {
1624         if (nservers <= 0)
1625             panic("afs_GetServer: incorrect count of servers");
1626
1627         ts = afs_SearchServer(aport, uuidp, locktype, &oldts, addr_uniquifier);
1628         if (ts) {
1629             ReleaseSharedLock(&afs_xserver);
1630             return ts;
1631         }
1632     }
1633
1634     /*
1635      * Lock hierarchy requires xvcb, then xserver. We *have* xserver.
1636      * Do a little dance and see if we can grab xvcb. If not, we
1637      * need to recheck that oldts is still right after a drop and reobtain.
1638      */
1639     if (EWOULDBLOCK == NBObtainWriteLock(&afs_xvcb, 300)) {
1640         ReleaseSharedLock(&afs_xserver);
1641         ObtainWriteLock(&afs_xvcb, 299);
1642         ObtainWriteLock(&afs_xserver, 35);
1643
1644         /* we don't know what changed while we didn't hold the lock */
1645         oldts = 0;
1646         ts = afs_SearchServer(aport, uuidp, locktype, &oldts,
1647                               addr_uniquifier);
1648         if (ts) {
1649             ReleaseWriteLock(&afs_xserver);
1650             ReleaseWriteLock(&afs_xvcb);
1651             return ts;
1652         }
1653     } else {
1654         UpgradeSToWLock(&afs_xserver, 36);
1655     }
1656     ObtainWriteLock(&afs_xsrvAddr, 116);
1657     srvcount = afs_totalServers;
1658
1659     /* Reuse/allocate a new server structure */
1660     if (oldts) {
1661         newts = oldts;
1662     } else {
1663         newts = afs_osi_Alloc(sizeof(struct server));
1664         if (!newts)
1665             panic("malloc of server struct");
1666         afs_totalServers++;
1667         memset(newts, 0, sizeof(struct server));
1668
1669         /* Add the server struct to the afs_servers[] hash chain */
1670         srvhash =
1671             (uuidp ? (afs_uuid_hash(uuidp) % NSERVERS) : SHash(aserverp[0]));
1672         newts->next = afs_servers[srvhash];
1673         afs_servers[srvhash] = newts;
1674     }
1675
1676     /* Initialize the server structure */
1677     if (uuidp) {                /* Multihomed */
1678         newts->sr_uuid = *uuidp;
1679         newts->sr_addr_uniquifier = addr_uniquifier;
1680         newts->flags |= SRVR_MULTIHOMED;
1681     }
1682     if (acell)
1683         /* Use the afs_GetCellStale variant to avoid afs_GetServer recursion. */
1684         newts->cell = afs_GetCellStale(acell, 0);
1685
1686     /* For each IP address we are registering */
1687     for (k = 0; k < nservers; k++) {
1688         iphash = SHash(aserverp[k]);
1689
1690         /* Check if the srvAddr structure already exists. If so, remove
1691          * it from its server structure and add it to the new one.
1692          */
1693         for (oldsa = afs_srvAddrs[iphash]; oldsa; oldsa = oldsa->next_bkt) {
1694             if ((oldsa->sa_ip == aserverp[k]) && (oldsa->sa_portal == aport))
1695                 break;
1696         }
1697         if (oldsa && (oldsa->server != newts)) {
1698             afs_RemoveSrvAddr(oldsa, tv);       /* Remove from its server struct */
1699             oldsa->next_sa = newts->addr;       /* Add to the  new server struct */
1700             newts->addr = oldsa;
1701         }
1702
1703         /* Reuse/allocate a new srvAddr structure */
1704         if (oldsa) {
1705             newsa = oldsa;
1706         } else {
1707             newsa = afs_osi_Alloc(sizeof(struct srvAddr));
1708             if (!newsa)
1709                 panic("malloc of srvAddr struct");
1710             afs_totalSrvAddrs++;
1711             memset(newsa, 0, sizeof(struct srvAddr));
1712
1713             /* Add the new srvAddr to the afs_srvAddrs[] hash chain */
1714             newsa->next_bkt = afs_srvAddrs[iphash];
1715             afs_srvAddrs[iphash] = newsa;
1716
1717             /* Hang off of the server structure  */
1718             newsa->next_sa = newts->addr;
1719             newts->addr = newsa;
1720
1721             /* Initialize the srvAddr Structure */
1722             newsa->sa_ip = aserverp[k];
1723             newsa->sa_portal = aport;
1724         }
1725
1726         /* Update the srvAddr Structure */
1727         newsa->server = newts;
1728         if (newts->flags & SRVR_ISDOWN)
1729             newsa->sa_flags |= SRVADDR_ISDOWN;
1730         if (uuidp)
1731             newsa->sa_flags |= SRVADDR_MH;
1732         else
1733             newsa->sa_flags &= ~SRVADDR_MH;
1734
1735         /* Compute preference values and resort */
1736         if (!newsa->sa_iprank) {
1737             afs_SetServerPrefs(newsa);  /* new server rank */
1738         }
1739     }
1740     afs_SortOneServer(newts);   /* Sort by rank */
1741
1742     /* If we reused the server struct, remove any of its srvAddr
1743      * structs that will no longer be associated with this server.
1744      */
1745     if (oldts) {                /* reused the server struct */
1746         for (orphsa = newts->addr; orphsa; orphsa = nextsa) {
1747             nextsa = orphsa->next_sa;
1748             for (k = 0; k < nservers; k++) {
1749                 if (orphsa->sa_ip == aserverp[k])
1750                     break;      /* belongs */
1751             }
1752             if (k < nservers)
1753                 continue;       /* belongs */
1754
1755             /* Have a srvAddr struct. Now get a server struct (if not already) */
1756             if (!orphts) {
1757                 orphts = afs_osi_Alloc(sizeof(struct server));
1758                 if (!orphts)
1759                     panic("malloc of lo server struct");
1760                 memset(orphts, 0, sizeof(struct server));
1761                 afs_totalServers++;
1762
1763                 /* Add the orphaned server to the afs_servers[] hash chain.
1764                  * Its iphash does not matter since we never look up the server
1765                  * in the afs_servers table by its ip address (only by uuid -
1766                  * which this has none).
1767                  */
1768                 iphash = SHash(aserverp[k]);
1769                 orphts->next = afs_servers[iphash];
1770                 afs_servers[iphash] = orphts;
1771
1772                 if (acell)
1773                     /* Use the afs_GetCellStale variant to avoid afs_GetServer recursion. */
1774                     orphts->cell = afs_GetCellStale(acell, 0);
1775             }
1776
1777             /* Hang the srvAddr struct off of the server structure. The server
1778              * may have multiple srvAddrs, but it won't be marked multihomed.
1779              */
1780             afs_RemoveSrvAddr(orphsa, tv);      /* remove */
1781             orphsa->next_sa = orphts->addr;     /* hang off server struct */
1782             orphts->addr = orphsa;
1783             orphsa->server = orphts;
1784             orphsa->sa_flags |= SRVADDR_NOUSE;  /* flag indicating not in use */
1785             orphsa->sa_flags &= ~SRVADDR_MH;    /* Not multihomed */
1786         }
1787     }
1788     /* We can't need this below, and won't reacquire */
1789     ReleaseWriteLock(&afs_xvcb);
1790
1791     srvcount = afs_totalServers - srvcount;     /* # servers added and removed */
1792     if (srvcount) {
1793         struct afs_stats_SrvUpDownInfo *upDownP;
1794         /* With the introduction of this new record, we need to adjust the
1795          * proper individual & global server up/down info.
1796          */
1797         upDownP = GetUpDownStats(newts);
1798         upDownP->numTtlRecords += srvcount;
1799         afs_stats_cmperf.srvRecords += srvcount;
1800         if (afs_stats_cmperf.srvRecords > afs_stats_cmperf.srvRecordsHWM)
1801             afs_stats_cmperf.srvRecordsHWM = afs_stats_cmperf.srvRecords;
1802     }
1803     /* We can't need this below, and won't reacquire */
1804     ReleaseWriteLock(&afs_xvcb);
1805
1806     ReleaseWriteLock(&afs_xsrvAddr);
1807
1808     if ( aport == AFS_FSPORT && !(newts->flags & SCAPS_KNOWN))
1809         afs_GetCapabilities(newts);
1810
1811     ReleaseWriteLock(&afs_xserver);
1812     return (newts);
1813 }                               /* afs_GetServer */
1814
1815 void
1816 afs_ActivateServer(struct srvAddr *sap)
1817 {
1818     osi_timeval32_t currTime;   /*Filled with current time */
1819     osi_timeval32_t *currTimeP; /*Ptr to above */
1820     struct afs_stats_SrvUpDownInfo *upDownP;    /*Ptr to up/down info record */
1821     struct server *aserver = sap->server;
1822
1823     if (!(aserver->flags & AFS_SERVER_FLAG_ACTIVATED)) {
1824         /*
1825          * This server record has not yet been activated.  Go for it,
1826          * recording its ``birth''.
1827          */
1828         aserver->flags |= AFS_SERVER_FLAG_ACTIVATED;
1829         currTimeP = &currTime;
1830         osi_GetTime(currTimeP);
1831         aserver->activationTime = currTime.tv_sec;
1832         upDownP = GetUpDownStats(aserver);
1833         if (aserver->flags & SRVR_ISDOWN) {
1834             upDownP->numDownRecords++;
1835         } else {
1836             upDownP->numUpRecords++;
1837             upDownP->numRecordsNeverDown++;
1838         }
1839     }
1840 }
1841
1842 void
1843 afs_RemoveAllConns(void)
1844 {
1845     int i;
1846     struct server *ts, *nts;
1847     struct srvAddr *sa;
1848
1849     ObtainReadLock(&afs_xserver);
1850     ObtainWriteLock(&afs_xconn, 1001);
1851
1852     /*printf("Destroying connections ... ");*/
1853     for (i = 0; i < NSERVERS; i++) {
1854         for (ts = afs_servers[i]; ts; ts = nts) {
1855             nts = ts->next;
1856             for (sa = ts->addr; sa; sa = sa->next_sa) {
1857                 if (sa->conns) {
1858                     afs_ReleaseConns(sa->conns);
1859                     sa->conns = NULL;
1860                     sa->natping = NULL;
1861                 }
1862             }
1863         }
1864     }
1865     /*printf("done\n");*/
1866
1867     ReleaseWriteLock(&afs_xconn);
1868     ReleaseReadLock(&afs_xserver);
1869
1870 }
1871
1872 void
1873 afs_MarkAllServersUp(void)
1874 {
1875     int i;
1876     struct server *ts;
1877     struct srvAddr *sa;
1878
1879     ObtainWriteLock(&afs_xserver, 721);
1880     ObtainWriteLock(&afs_xsrvAddr, 722);
1881     for (i = 0; i< NSERVERS; i++) {
1882         for (ts = afs_servers[i]; ts; ts = ts->next) {
1883             for (sa = ts->addr; sa; sa = sa->next_sa) {
1884                 afs_MarkServerUpOrDown(sa, 0);
1885             }
1886         }
1887     }
1888     ReleaseWriteLock(&afs_xsrvAddr);
1889     ReleaseWriteLock(&afs_xserver);
1890 }