2 * Copyright 2000, International Business Machines Corporation and others.
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
12 * afs_MarkServerUpOrDown
20 * afsi_SetServerIPRank
32 #include <afsconfig.h>
33 #include "afs/param.h"
37 #include "afs/sysincludes.h" /* Standard vendor system headers */
40 #if !defined(AFS_LINUX20_ENV)
43 #include <netinet/in.h>
46 #include "h/hashing.h"
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 */
52 #include <net/if_var.h>
54 #endif /* !defined(UKERNEL) */
56 #include "afsincludes.h" /* Afs-based standard headers */
57 #include "afs/afs_stats.h" /* afs statistics */
58 #include "rx/rx_multi.h"
60 #if defined(AFS_SUN56_ENV)
62 #include <inet/common.h>
63 #if defined(AFS_SUN58_ENV)
64 # include <netinet/ip6.h>
65 # define ipif_local_addr ipif_lcl_addr
66 # ifndef V4_PART_OF_V6
67 # define V4_PART_OF_V6(v6) v6.s6_addr32[3]
73 /* Exported variables */
74 afs_rwlock_t afs_xserver; /* allocation lock for servers */
75 struct server *afs_setTimeHost = 0; /* last host we used for time */
76 struct server *afs_servers[NSERVERS]; /* Hashed by server`s uuid & 1st ip */
77 afs_rwlock_t afs_xsrvAddr; /* allocation lock for srvAddrs */
78 struct srvAddr *afs_srvAddrs[NSERVERS]; /* Hashed by server's ip */
81 /* debugging aids - number of alloc'd server and srvAddr structs. */
82 int afs_reuseServers = 0;
83 int afs_reuseSrvAddrs = 0;
84 int afs_totalServers = 0;
85 int afs_totalSrvAddrs = 0;
89 static struct afs_stats_SrvUpDownInfo *
90 GetUpDownStats(struct server *srv)
92 struct afs_stats_SrvUpDownInfo *upDownP;
93 u_short fsport = AFS_FSPORT;
96 fsport = srv->cell->fsport;
98 if (srv->addr->sa_portal == fsport)
99 upDownP = afs_stats_cmperf.fs_UpDown;
101 upDownP = afs_stats_cmperf.vl_UpDown;
103 if (srv->cell && afs_IsPrimaryCell(srv->cell))
104 return &upDownP[AFS_STATS_UPDOWN_IDX_SAME_CELL];
106 return &upDownP[AFS_STATS_UPDOWN_IDX_DIFF_CELL];
110 /*------------------------------------------------------------------------
111 * afs_MarkServerUpOrDown
114 * Mark the given server up or down, and track its uptime stats.
117 * a_serverP : Ptr to server record to fiddle with.
118 * a_isDown : Is the server is to be marked down?
124 * The CM server structures must be write-locked.
128 *------------------------------------------------------------------------*/
131 afs_MarkServerUpOrDown(struct srvAddr *sa, int a_isDown)
133 struct server *a_serverP = sa->server;
135 osi_timeval_t currTime, *currTimeP; /*Current time */
136 afs_int32 downTime; /*Computed downtime, in seconds */
137 struct afs_stats_SrvUpDownInfo *upDownP; /*Ptr to up/down info record */
140 * If the server record is marked the same as the new status we've
141 * been fed, then there isn't much to be done.
143 if ((a_isDown && (sa->sa_flags & SRVADDR_ISDOWN))
144 || (!a_isDown && !(sa->sa_flags & SRVADDR_ISDOWN)))
148 sa->sa_flags |= SRVADDR_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 */
157 * All ips are down we treat the whole server down
159 a_serverP->flags |= SRVR_ISDOWN;
161 * If this was our time server, search for another time server
163 if (a_serverP == afs_setTimeHost)
166 sa->sa_flags &= ~SRVADDR_ISDOWN;
167 /* If any ips are up, the server is also marked up */
168 a_serverP->flags &= ~SRVR_ISDOWN;
169 for (sap = a_serverP->addr; sap; sap = sap->next_sa) {
170 if (sap->sa_flags & SRVADDR_ISDOWN) {
171 /* Not all ips are up so don't bother with the
172 * server's up/down stats */
179 * Compute the current time and which overall stats record is to be
180 * updated; we'll need them one way or another.
182 currTimeP = &currTime;
183 osi_GetuTime(currTimeP);
185 upDownP = GetUpDownStats(a_serverP);
189 * Server going up -> down; remember the beginning of this
192 a_serverP->lastDowntimeStart = currTime.tv_sec;
194 (upDownP->numDownRecords)++;
195 (upDownP->numUpRecords)--;
196 } /*Server being marked down */
199 * Server going down -> up; remember everything about this
200 * newly-completed downtime incident.
202 downTime = currTime.tv_sec - a_serverP->lastDowntimeStart;
203 (a_serverP->numDowntimeIncidents)++;
204 a_serverP->sumOfDowntimes += downTime;
206 (upDownP->numUpRecords)++;
207 (upDownP->numDownRecords)--;
208 (upDownP->numDowntimeIncidents)++;
209 if (a_serverP->numDowntimeIncidents == 1)
210 (upDownP->numRecordsNeverDown)--;
211 upDownP->sumOfDowntimes += downTime;
212 if ((upDownP->shortestDowntime == 0)
213 || (downTime < upDownP->shortestDowntime))
214 upDownP->shortestDowntime = downTime;
215 if ((upDownP->longestDowntime == 0)
216 || (downTime > upDownP->longestDowntime))
217 upDownP->longestDowntime = downTime;
220 if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET0)
221 (upDownP->downDurations[0])++;
222 else if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET1)
223 (upDownP->downDurations[1])++;
224 else if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET2)
225 (upDownP->downDurations[2])++;
226 else if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET3)
227 (upDownP->downDurations[3])++;
228 else if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET4)
229 (upDownP->downDurations[4])++;
230 else if (downTime <= AFS_STATS_MAX_DOWNTIME_DURATION_BUCKET5)
231 (upDownP->downDurations[5])++;
233 (upDownP->downDurations[6])++;
235 } /*Server being marked up */
237 } /*MarkServerUpOrDown */
241 afs_ServerDown(struct srvAddr *sa)
243 struct server *aserver = sa->server;
245 AFS_STATCNT(ServerDown);
246 if (aserver->flags & SRVR_ISDOWN || sa->sa_flags & SRVADDR_ISDOWN)
248 afs_MarkServerUpOrDown(sa, SRVR_ISDOWN);
249 if (sa->sa_portal == aserver->cell->vlport)
250 print_internet_address
251 ("afs: Lost contact with volume location server ", sa, "", 1);
253 print_internet_address("afs: Lost contact with file server ", sa, "",
259 /* return true if we have any callback promises from this server */
261 afs_HaveCallBacksFrom(struct server *aserver)
267 AFS_STATCNT(HaveCallBacksFrom);
268 now = osi_Time(); /* for checking for expired callbacks */
269 for (i = 0; i < VCSIZE; i++) { /* for all guys in the hash table */
270 for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
272 * Check to see if this entry has an unexpired callback promise
273 * from the required host
275 if (aserver == tvc->callback && tvc->cbExpires >= now
276 && ((tvc->f.states & CRO) == 0))
282 } /*HaveCallBacksFrom */
286 CheckVLServer(struct srvAddr *sa, struct vrequest *areq)
288 struct server *aserver = sa->server;
292 AFS_STATCNT(CheckVLServer);
293 /* Ping dead servers to see if they're back */
294 if (!((aserver->flags & SRVR_ISDOWN) || (sa->sa_flags & SRVADDR_ISDOWN))
295 || (aserver->flags & SRVR_ISGONE))
298 return; /* can't do much */
300 tc = afs_ConnByHost(aserver, aserver->cell->vlport,
301 aserver->cell->cellNum, areq, 1, SHARED_LOCK);
304 rx_SetConnDeadTime(tc->id, 3);
307 code = VL_ProbeServer(tc->id);
309 rx_SetConnDeadTime(tc->id, afs_rx_deadtime);
310 afs_PutConn(tc, SHARED_LOCK);
312 * If probe worked, or probe call not yet defined (for compatibility
313 * with old vlsevers), then we treat this server as running again
315 if (code == 0 || (code <= -450 && code >= -470)) {
316 if (tc->srvr == sa) {
317 afs_MarkServerUpOrDown(sa, 0);
318 print_internet_address("afs: volume location server ", sa,
326 #ifndef AFS_MINCHANGE /* So that some can increase it in param.h */
327 #define AFS_MINCHANGE 2 /* min change we'll bother with */
329 #ifndef AFS_MAXCHANGEBACK
330 #define AFS_MAXCHANGEBACK 10 /* max seconds we'll set a clock back at once */
334 /*------------------------------------------------------------------------
335 * EXPORTED afs_CountServers
338 * Originally meant to count the number of servers and determining
339 * up/down info, this routine will now simply sum up all of the
340 * server record ages. All other up/down information is kept on the
350 * This routine locks afs_xserver for write for the duration.
353 * Set CM perf stats field sumOfRecordAges for all server record
355 *------------------------------------------------------------------------*/
358 afs_CountServers(void)
360 int currIdx; /*Curr idx into srv table */
361 struct server *currSrvP; /*Ptr to curr server record */
362 afs_int32 currChainLen; /*Length of curr hash chain */
363 osi_timeval_t currTime; /*Current time */
364 osi_timeval_t *currTimeP; /*Ptr to above */
365 afs_int32 srvRecordAge; /*Age of server record, in secs */
366 struct afs_stats_SrvUpDownInfo *upDownP; /*Ptr to current up/down
367 * info being manipulated */
370 * Write-lock the server table so we don't get any interference.
372 ObtainReadLock(&afs_xserver);
375 * Iterate over each hash index in the server table, walking down each
376 * chain and tallying what we haven't computed from the records there on
377 * the fly. First, though, initialize the tallies that will change.
379 afs_stats_cmperf.srvMaxChainLength = 0;
381 afs_stats_cmperf.fs_UpDown[0].sumOfRecordAges = 0;
382 afs_stats_cmperf.fs_UpDown[0].ageOfYoungestRecord = 0;
383 afs_stats_cmperf.fs_UpDown[0].ageOfOldestRecord = 0;
384 memset(afs_stats_cmperf.fs_UpDown[0].downIncidents, 0,
385 AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
387 afs_stats_cmperf.fs_UpDown[1].sumOfRecordAges = 0;
388 afs_stats_cmperf.fs_UpDown[1].ageOfYoungestRecord = 0;
389 afs_stats_cmperf.fs_UpDown[1].ageOfOldestRecord = 0;
390 memset(afs_stats_cmperf.fs_UpDown[1].downIncidents, 0,
391 AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
393 afs_stats_cmperf.vl_UpDown[0].sumOfRecordAges = 0;
394 afs_stats_cmperf.vl_UpDown[0].ageOfYoungestRecord = 0;
395 afs_stats_cmperf.vl_UpDown[0].ageOfOldestRecord = 0;
396 memset(afs_stats_cmperf.vl_UpDown[0].downIncidents, 0,
397 AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
399 afs_stats_cmperf.vl_UpDown[1].sumOfRecordAges = 0;
400 afs_stats_cmperf.vl_UpDown[1].ageOfYoungestRecord = 0;
401 afs_stats_cmperf.vl_UpDown[1].ageOfOldestRecord = 0;
402 memset(afs_stats_cmperf.vl_UpDown[1].downIncidents, 0,
403 AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
406 * Compute the current time, used to figure out server record ages.
408 currTimeP = &currTime;
409 osi_GetuTime(currTimeP);
412 * Sweep the server hash table, tallying all we need to know.
414 for (currIdx = 0; currIdx < NSERVERS; currIdx++) {
416 for (currSrvP = afs_servers[currIdx]; currSrvP;
417 currSrvP = currSrvP->next) {
419 * Bump the current chain length.
424 * Any further tallying for this record will only be done if it has
427 if ((currSrvP->flags & AFS_SERVER_FLAG_ACTIVATED)
428 && currSrvP->addr && currSrvP->cell) {
431 * Compute the current server record's age, then remember it
432 * in the appropriate places.
434 srvRecordAge = currTime.tv_sec - currSrvP->activationTime;
435 upDownP = GetUpDownStats(currSrvP);
436 upDownP->sumOfRecordAges += srvRecordAge;
437 if ((upDownP->ageOfYoungestRecord == 0)
438 || (srvRecordAge < upDownP->ageOfYoungestRecord))
439 upDownP->ageOfYoungestRecord = srvRecordAge;
440 if ((upDownP->ageOfOldestRecord == 0)
441 || (srvRecordAge > upDownP->ageOfOldestRecord))
442 upDownP->ageOfOldestRecord = srvRecordAge;
444 if (currSrvP->numDowntimeIncidents <=
445 AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET0)
446 (upDownP->downIncidents[0])++;
447 else if (currSrvP->numDowntimeIncidents <=
448 AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET1)
449 (upDownP->downIncidents[1])++;
450 else if (currSrvP->numDowntimeIncidents <=
451 AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET2)
452 (upDownP->downIncidents[2])++;
453 else if (currSrvP->numDowntimeIncidents <=
454 AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET3)
455 (upDownP->downIncidents[3])++;
456 else if (currSrvP->numDowntimeIncidents <=
457 AFS_STATS_MAX_DOWNTIME_INCIDENTS_BUCKET4)
458 (upDownP->downIncidents[4])++;
460 (upDownP->downIncidents[5])++;
463 } /*Current server has been active */
464 } /*Walk this chain */
467 * Before advancing to the next chain, remember facts about this one.
469 if (currChainLen > afs_stats_cmperf.srvMaxChainLength) {
471 * We beat out the former champion (which was initially set to 0
472 * here). Mark down the new winner, and also remember if it's an
475 afs_stats_cmperf.srvMaxChainLength = currChainLen;
476 if (currChainLen > afs_stats_cmperf.srvMaxChainLengthHWM)
477 afs_stats_cmperf.srvMaxChainLengthHWM = currChainLen;
478 } /*Update chain length maximum */
479 } /*For each hash chain */
482 * We're done. Unlock the server table before returning to our caller.
484 ReleaseReadLock(&afs_xserver);
486 } /*afs_CountServers */
490 ForceAllNewConnections(void)
493 struct srvAddr **addrs;
497 ObtainReadLock(&afs_xserver); /* Necessary? */
498 ObtainReadLock(&afs_xsrvAddr);
501 for (i = 0; i < NSERVERS; i++) {
502 for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
507 addrs = afs_osi_Alloc(srvAddrCount * sizeof(*addrs));
508 osi_Assert(addrs != NULL);
510 for (i = 0; i < NSERVERS; i++) {
511 for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
512 if (j >= srvAddrCount)
518 ReleaseReadLock(&afs_xsrvAddr);
519 ReleaseReadLock(&afs_xserver);
520 for (i = 0; i < j; i++) {
522 ForceNewConnections(sa);
526 /* check down servers (if adown), or running servers (if !adown) */
528 afs_CheckServers(int adown, struct cell *acellp)
530 struct vrequest treq;
536 afs_int32 start, end = 0, delta;
541 struct srvAddr **addrs;
542 struct afs_conn **conns;
544 struct rx_connection **rxconns;
545 afs_int32 *conntimer, *deltas, *results;
546 Capabilities *caps = NULL;
548 AFS_STATCNT(afs_CheckServers);
551 * No sense in doing the server checks if we are running in disconnected
554 if (AFS_IS_DISCONNECTED)
557 conns = (struct afs_conn **)0;
558 rxconns = (struct rx_connection **) 0;
562 if ((code = afs_InitReq(&treq, afs_osi_credp)))
564 ObtainReadLock(&afs_xserver); /* Necessary? */
565 ObtainReadLock(&afs_xsrvAddr);
568 for (i = 0; i < NSERVERS; i++) {
569 for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
574 addrs = afs_osi_Alloc(srvAddrCount * sizeof(*addrs));
575 osi_Assert(addrs != NULL);
577 for (i = 0; i < NSERVERS; i++) {
578 for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
579 if (j >= srvAddrCount)
585 ReleaseReadLock(&afs_xsrvAddr);
586 ReleaseReadLock(&afs_xserver);
588 conns = afs_osi_Alloc(j * sizeof(struct afs_conn *));
589 osi_Assert(conns != NULL);
590 rxconns = afs_osi_Alloc(j * sizeof(struct rx_connection *));
591 osi_Assert(rxconns != NULL);
592 conntimer = afs_osi_Alloc(j * sizeof (afs_int32));
593 osi_Assert(conntimer != NULL);
594 deltas = afs_osi_Alloc(j * sizeof (afs_int32));
595 osi_Assert(deltas != NULL);
596 results = afs_osi_Alloc(j * sizeof (afs_int32));
597 osi_Assert(results != NULL);
599 caps = afs_osi_Alloc(j * sizeof (Capabilities));
600 osi_Assert(caps != NULL);
601 memset(caps, 0, j * sizeof(Capabilities));
603 for (i = 0; i < j; i++) {
610 /* See if a cell to check was specified. If it is spec'd and not
611 * this server's cell, just skip the server.
613 if (acellp && acellp != ts->cell)
616 if ((!adown && (sa->sa_flags & SRVADDR_ISDOWN))
617 || (adown && !(sa->sa_flags & SRVADDR_ISDOWN)))
620 /* check vlserver with special code */
621 if (sa->sa_portal == AFS_VLPORT) {
622 CheckVLServer(sa, &treq);
626 if (!ts->cell) /* not really an active server, anyway, it must */
627 continue; /* have just been added by setsprefs */
629 /* get a connection, even if host is down; bumps conn ref count */
630 tu = afs_GetUser(treq.uid, ts->cell->cellNum, SHARED_LOCK);
631 tc = afs_ConnBySA(sa, ts->cell->fsport, ts->cell->cellNum, tu,
632 1 /*force */ , 1 /*create */ , SHARED_LOCK);
633 afs_PutUser(tu, SHARED_LOCK);
637 if ((sa->sa_flags & SRVADDR_ISDOWN) || afs_HaveCallBacksFrom(sa->server)
638 || (tc->srvr->server == afs_setTimeHost)) {
640 rxconns[nconns]=tc->id;
641 if (sa->sa_flags & SRVADDR_ISDOWN) {
642 rx_SetConnDeadTime(tc->id, 3);
649 } /* Outer loop over addrs */
652 multi_Rx(rxconns,nconns)
654 multi_RXAFS_GetCapabilities(&caps[multi_i]);
655 results[multi_i] = multi_error;
659 for ( i = 0 ; i < nconns ; i++ ) {
660 ts = addrs[i]->server;
663 ts->capabilities = 0;
664 ts->flags |= SCAPS_KNOWN;
665 if ( results[i] == RXGEN_OPCODE ) {
666 /* Mark server as up - it responded */
670 if ( results[i] >= 0 )
671 /* we currently handle 32-bits of capabilities */
672 if (caps[i].Capabilities_len > 0) {
673 ts->capabilities = caps[i].Capabilities_val[0];
674 xdr_free((xdrproc_t)xdr_Capabilities, &caps[i]);
675 caps[i].Capabilities_val = NULL;
676 caps[i].Capabilities_len = 0;
680 if ( afs_setTime != 0 ) {
681 start = osi_Time(); /* time the gettimeofday call */
683 if ( afs_setTimeHost == NULL ) {
684 multi_Rx(rxconns,nconns)
686 tv.tv_sec = tv.tv_usec = 0;
688 (afs_uint32 *)&tv.tv_sec, (afs_uint32 *)&tv.tv_usec);
691 if (conntimer[multi_i] == 1)
692 rx_SetConnDeadTime(tc->id, afs_rx_deadtime);
694 results[multi_i]=multi_error;
695 if ((start == end) && !multi_error)
696 deltas[multi_i] = end - tv.tv_sec;
700 else { /* find and query setTimeHost only */
701 for ( i = 0 ; i < j ; i++ ) {
702 if ( conns[i] == NULL || conns[i]->srvr == NULL )
704 if ( conns[i]->srvr->server == afs_setTimeHost ) {
705 tv.tv_sec = tv.tv_usec = 0;
706 results[i] = RXAFS_GetTime(rxconns[i],
707 (afs_uint32 *)&tv.tv_sec, (afs_uint32 *)&tv.tv_usec);
709 if ((start == end) && !results[i])
710 deltas[i] = end - tv.tv_sec;
718 for(i=0;i<nconns;i++){
722 if (( results[i] >= 0 ) && (sa->sa_flags & SRVADDR_ISDOWN) && (tc->srvr == sa)) {
724 print_internet_address("afs: file server ", sa, " is back up", 2);
726 ObtainWriteLock(&afs_xserver, 244);
727 ObtainWriteLock(&afs_xsrvAddr, 245);
728 afs_MarkServerUpOrDown(sa, 0);
729 ReleaseWriteLock(&afs_xsrvAddr);
730 ReleaseWriteLock(&afs_xserver);
732 if (afs_waitForeverCount) {
733 afs_osi_Wakeup(&afs_waitForever);
736 if (results[i] < 0) {
739 ForceNewConnections(sa); /* multi homed clients */
745 * If we're supposed to set the time, and the call worked
746 * quickly (same second response) and this is the host we
747 * use for the time and the time is really different, then
748 * really set the time
750 if (afs_setTime != 0) {
751 for (i=0; i<nconns; i++) {
756 if ((tc->srvr->server == afs_setTimeHost ||
757 /* Sync only to a server in the local cell */
758 (afs_setTimeHost == (struct server *)0 &&
759 afs_IsPrimaryCell(sa->server->cell)))) {
761 char msgbuf[90]; /* strlen("afs: setting clock...") + slop */
762 delta = end - tv.tv_sec; /* how many secs fast we are */
764 afs_setTimeHost = tc->srvr->server;
765 /* see if clock has changed enough to make it worthwhile */
766 if (delta >= AFS_MINCHANGE || delta <= -AFS_MINCHANGE) {
768 if (delta > AFS_MAXCHANGEBACK) {
769 /* setting clock too far back, just do it a little */
770 tv.tv_sec = end - AFS_MAXCHANGEBACK;
772 tv.tv_sec = end - delta;
774 afs_osi_SetTime(&tv);
776 strcpy(msgbuf, "afs: setting clock back ");
777 if (delta > AFS_MAXCHANGEBACK) {
779 afs_cv2string(&tbuffer[CVBS],
781 afs_strcat(msgbuf, " seconds (of ");
783 afs_cv2string(&tbuffer[CVBS],
786 afs_strcat(msgbuf, ", via ");
787 print_internet_address(msgbuf, sa,
788 "); clock is still fast.",
792 afs_cv2string(&tbuffer[CVBS], delta));
793 afs_strcat(msgbuf, " seconds (via ");
794 print_internet_address(msgbuf, sa, ").", 0);
797 strcpy(msgbuf, "afs: setting clock ahead ");
799 afs_cv2string(&tbuffer[CVBS], -delta));
800 afs_strcat(msgbuf, " seconds (via ");
801 print_internet_address(msgbuf, sa, ").", 0);
803 /* We're only going to set it once; why bother looping? */
809 for (i = 0; i < nconns; i++) {
810 afs_PutConn(conns[i], SHARED_LOCK); /* done with it now */
813 afs_osi_Free(addrs, srvAddrCount * sizeof(*addrs));
814 afs_osi_Free(conns, j * sizeof(struct afs_conn *));
815 afs_osi_Free(rxconns, j * sizeof(struct rx_connection *));
816 afs_osi_Free(conntimer, j * sizeof(afs_int32));
817 afs_osi_Free(deltas, j * sizeof(afs_int32));
818 afs_osi_Free(results, j * sizeof(afs_int32));
819 afs_osi_Free(caps, j * sizeof(Capabilities));
821 } /*afs_CheckServers*/
824 /* find a server structure given the host address */
826 afs_FindServer(afs_int32 aserver, afs_uint16 aport, afsUUID * uuidp,
833 AFS_STATCNT(afs_FindServer);
835 i = afs_uuid_hash(uuidp) % NSERVERS;
836 for (ts = afs_servers[i]; ts; ts = ts->next) {
837 if ((ts->flags & SRVR_MULTIHOMED)
839 (memcmp((char *)uuidp, (char *)&ts->sr_uuid, sizeof(*uuidp))
840 == 0) && (!ts->addr || (ts->addr->sa_portal == aport)))
845 for (sa = afs_srvAddrs[i]; sa; sa = sa->next_bkt) {
846 if ((sa->sa_ip == aserver) && (sa->sa_portal == aport)) {
853 } /*afs_FindServer */
856 /* some code for creating new server structs and setting preferences follows
857 * in the next few lines...
860 #define MAXDEFRANK 60000
861 #define DEFRANK 40000
863 /* Random number generator and constants from KnuthV2 2d ed, p170 */
869 a is 0.73m should be 0.01m .. 0.99m
870 c is more or less immaterial. 1 or a is suggested.
872 NB: LOW ORDER BITS are not very random. To get small random numbers,
873 treat result as <1, with implied binary point, and multiply by
875 NB: Has to be unsigned, since shifts on signed quantities may preserve
878 /* added rxi_getaddr() to try to get as much initial randomness as
879 possible, since at least one customer reboots ALL their clients
880 simultaneously -- so osi_Time is bound to be the same on some of the
881 clients. This is probably OK, but I don't want to see too much of it.
884 #define ranstage(x) (x)= (afs_uint32) (3141592621U*((afs_uint32)x)+1)
889 static afs_int32 state = 0;
892 AFS_STATCNT(afs_random);
897 * 0xfffffff0 was changed to (~0 << 4) since it works no matter how many
898 * bits are in a tv_usec
900 state = (t.tv_usec & (~0 << 4)) + (rxi_getaddr() & 0xff);
901 state += (t.tv_sec & 0xff);
902 for (i = 0; i < 30; i++) {
912 /* returns int 0..14 using the high bits of a pseudo-random number instead of
913 the low bits, as the low bits are "less random" than the high ones...
914 slight roundoff error exists, an excercise for the reader.
915 need to multiply by something with lots of ones in it, so multiply by
916 8 or 16 is right out.
919 afs_randomMod15(void)
923 temp = afs_random() >> 4;
924 temp = (temp * 15) >> 28;
930 afs_randomMod127(void)
934 temp = afs_random() >> 7;
935 temp = (temp * 127) >> 25;
940 /* afs_SortOneServer()
941 * Sort all of the srvAddrs, of a server struct, by rank from low to high.
944 afs_SortOneServer(struct server *asp)
946 struct srvAddr **rootsa, *lowsa, *tsa, *lowprev;
949 for (rootsa = &(asp->addr); *rootsa; rootsa = &(lowsa->next_sa)) {
951 lowsa = *rootsa; /* lowest sa is the first one */
952 lowrank = lowsa->sa_iprank;
954 for (tsa = *rootsa; tsa->next_sa; tsa = tsa->next_sa) {
955 rank = tsa->next_sa->sa_iprank;
956 if (rank < lowrank) {
958 lowsa = tsa->next_sa;
959 lowrank = lowsa->sa_iprank;
962 if (lowprev) { /* found one lower, so rearrange them */
963 lowprev->next_sa = lowsa->next_sa;
964 lowsa->next_sa = *rootsa;
971 * Sort the pointer to servers by the server's rank (its lowest rank).
972 * It is assumed that the server already has its IP addrs sorted (the
973 * first being its lowest rank: afs_GetServer() calls afs_SortOneServer()).
976 afs_SortServers(struct server *aservers[], int count)
981 AFS_STATCNT(afs_SortServers);
983 for (i = 0; i < count; i++) {
986 for (low = i, j = i + 1; j <= count; j++) {
987 if ((!aservers[j]) || (!aservers[j]->addr))
989 if ((!aservers[low]) || (!aservers[low]->addr))
991 if (aservers[j]->addr->sa_iprank < aservers[low]->addr->sa_iprank) {
997 aservers[i] = aservers[low];
1001 } /*afs_SortServers */
1003 /* afs_SetServerPrefs is rather system-dependent. It pokes around in kernel
1004 data structures to determine what the local IP addresses and subnet masks
1005 are in order to choose which server(s) are on the local subnet.
1007 As I see it, there are several cases:
1008 1. The server address is one of this host's local addresses. In this case
1009 this server is to be preferred over all others.
1010 2. The server is on the same subnet as one of the this host's local
1011 addresses. (ie, an odd-sized subnet, not class A,B,orC)
1012 3. The server is on the same net as this host (class A,B or C)
1013 4. The server is on a different logical subnet or net than this host, but
1014 this host is a 'metric 0 gateway' to it. Ie, two address-spaces share
1015 one physical medium.
1016 5. This host has a direct (point-to-point, ie, PPP or SLIP) link to the
1018 6. This host and the server are disjoint.
1020 That is a rough order of preference. If a point-to-point link has a high
1021 metric, I'm assuming that it is a very slow link, and putting it at the
1022 bottom of the list (at least until RX works better over slow links). If
1023 its metric is 1, I'm assuming that it's relatively fast (T1) and putting
1025 It's not easy to check for case #4, so I'm ignoring it for the time being.
1027 BSD "if" code keeps track of some rough network statistics (cf 'netstat -i')
1028 That could be used to prefer certain servers fairly easily. Maybe some
1031 NOTE: this code is very system-dependent, and very dependent on the TCP/IP
1032 protocols (well, addresses that are stored in uint32s, at any rate).
1035 #define IA_DST(ia)((struct sockaddr_in *)(&((struct in_ifaddr *)ia)->ia_dstaddr))
1036 #define IA_BROAD(ia)((struct sockaddr_in *)(&((struct in_ifaddr *)ia)->ia_broadaddr))
1038 /* SA2ULONG takes a sockaddr_in, not a sockaddr (same thing, just cast it!) */
1039 #define SA2ULONG(sa) ((sa)->sin_addr.s_addr)
1044 #define PPWEIGHT 4096
1049 #if defined(AFS_SUN5_ENV) && ! defined(AFS_SUN56_ENV)
1050 #include <inet/common.h>
1051 /* IP interface structure, one per local address */
1052 typedef struct ipif_s {
1053 /**/ struct ipif_s *ipif_next;
1054 struct ill_s *ipif_ill; /* Back pointer to our ill */
1055 long ipif_id; /* Logical unit number */
1056 u_int ipif_mtu; /* Starts at ipif_ill->ill_max_frag */
1057 afs_int32 ipif_local_addr; /* Local IP address for this if. */
1058 afs_int32 ipif_net_mask; /* Net mask for this interface. */
1059 afs_int32 ipif_broadcast_addr; /* Broadcast addr for this interface. */
1060 afs_int32 ipif_pp_dst_addr; /* Point-to-point dest address. */
1061 u_int ipif_flags; /* Interface flags. */
1062 u_int ipif_metric; /* BSD if metric, for compatibility. */
1063 u_int ipif_ire_type; /* LOCAL or LOOPBACK */
1064 mblk_t *ipif_arp_down_mp; /* Allocated at time arp comes up to
1065 * prevent awkward out of mem condition
1068 mblk_t *ipif_saved_ire_mp; /* Allocated for each extra IRE_SUBNET/
1069 * RESOLVER on this interface so that
1070 * they can survive ifconfig down.
1073 * The packet counts in the ipif contain the sum of the
1074 * packet counts in dead IREs that were affiliated with
1077 u_long ipif_fo_pkt_count; /* Forwarded thru our dead IREs */
1078 u_long ipif_ib_pkt_count; /* Inbound packets for our dead IREs */
1079 u_long ipif_ob_pkt_count; /* Outbound packets to our dead IREs */
1081 ipif_multicast_up:1, /* We have joined the allhosts group */
1085 typedef struct ipfb_s {
1086 /**/ struct ipf_s *ipfb_ipf; /* List of ... */
1087 kmutex_t ipfb_lock; /* Protect all ipf in list */
1090 typedef struct ilm_s {
1091 /**/ afs_int32 ilm_addr;
1093 u_int ilm_timer; /* IGMP */
1094 struct ipif_s *ilm_ipif; /* Back pointer to ipif */
1095 struct ilm_s *ilm_next; /* Linked list for each ill */
1098 typedef struct ill_s {
1099 /**/ struct ill_s *ill_next; /* Chained in at ill_g_head. */
1100 struct ill_s **ill_ptpn; /* Pointer to previous next. */
1101 queue_t *ill_rq; /* Read queue. */
1102 queue_t *ill_wq; /* Write queue. */
1104 int ill_error; /* Error value sent up by device. */
1106 ipif_t *ill_ipif; /* Interface chain for this ILL. */
1107 u_int ill_ipif_up_count; /* Number of IPIFs currently up. */
1108 u_int ill_max_frag; /* Max IDU. */
1109 char *ill_name; /* Our name. */
1110 u_int ill_name_length; /* Name length, incl. terminator. */
1111 u_int ill_subnet_type; /* IRE_RESOLVER or IRE_SUBNET. */
1112 u_int ill_ppa; /* Physical Point of Attachment num. */
1114 int ill_sap_length; /* Including sign (for position) */
1115 u_int ill_phys_addr_length; /* Excluding the sap. */
1116 mblk_t *ill_frag_timer_mp; /* Reassembly timer state. */
1117 ipfb_t *ill_frag_hash_tbl; /* Fragment hash list head. */
1119 queue_t *ill_bind_pending_q; /* Queue waiting for DL_BIND_ACK. */
1120 ipif_t *ill_ipif_pending; /* IPIF waiting for DL_BIND_ACK. */
1122 /* ill_hdr_length and ill_hdr_mp will be non zero if
1123 * the underlying device supports the M_DATA fastpath
1127 ilm_t *ill_ilm; /* Multicast mebership for lower ill */
1129 /* All non-nil cells between 'ill_first_mp_to_free' and
1130 * 'ill_last_mp_to_free' are freed in ill_delete.
1132 #define ill_first_mp_to_free ill_hdr_mp
1133 mblk_t *ill_hdr_mp; /* Contains fastpath template */
1134 mblk_t *ill_bcast_mp; /* DLPI header for broadcasts. */
1135 mblk_t *ill_bind_pending; /* T_BIND_REQ awaiting completion. */
1136 mblk_t *ill_resolver_mp; /* Resolver template. */
1137 mblk_t *ill_attach_mp;
1138 mblk_t *ill_bind_mp;
1139 mblk_t *ill_unbind_mp;
1140 mblk_t *ill_detach_mp;
1141 #define ill_last_mp_to_free ill_detach_mp
1143 u_int ill_frag_timer_running:1, ill_needs_attach:1, ill_is_ptp:1,
1144 ill_priv_stream:1, ill_unbind_pending:1, ill_pad_to_bit_31:27;
1145 MI_HRT_DCL(ill_rtime)
1146 MI_HRT_DCL(ill_rtmp)
1150 #ifdef AFS_USERSPACE_IP_ADDR
1152 #define afs_min(A,B) ((A)<(B)) ? (A) : (B)
1155 * The IP addresses and ranks are determined by afsd (in user space) and
1156 * passed into the kernel at startup time through the AFSOP_ADVISEADDR
1157 * system call. These are stored in the data structure
1158 * called 'afs_cb_interface'.
1160 * struct srvAddr *sa; remote server
1161 * afs_int32 addr; one of my local addr in net order
1162 * afs_uint32 subnetmask; subnet mask of local addr in net order
1166 afsi_SetServerIPRank(struct srvAddr *sa, afs_int32 addr,
1167 afs_uint32 subnetmask)
1169 afs_uint32 myAddr, myNet, mySubnet, netMask;
1170 afs_uint32 serverAddr;
1172 myAddr = ntohl(addr); /* one of my IP addr in host order */
1173 serverAddr = ntohl(sa->sa_ip); /* server's IP addr in host order */
1174 subnetmask = ntohl(subnetmask); /* subnet mask in host order */
1176 if (IN_CLASSA(myAddr))
1177 netMask = IN_CLASSA_NET;
1178 else if (IN_CLASSB(myAddr))
1179 netMask = IN_CLASSB_NET;
1180 else if (IN_CLASSC(myAddr))
1181 netMask = IN_CLASSC_NET;
1185 myNet = myAddr & netMask;
1186 mySubnet = myAddr & subnetmask;
1188 if ((serverAddr & netMask) == myNet) {
1189 if ((serverAddr & subnetmask) == mySubnet) {
1190 if (serverAddr == myAddr) { /* same machine */
1191 sa->sa_iprank = afs_min(sa->sa_iprank, TOPR);
1192 } else { /* same subnet */
1193 sa->sa_iprank = afs_min(sa->sa_iprank, HI);
1195 } else { /* same net */
1196 sa->sa_iprank = afs_min(sa->sa_iprank, MED);
1201 #else /* AFS_USERSPACE_IP_ADDR */
1202 #if (! defined(AFS_SUN5_ENV)) && !defined(AFS_DARWIN_ENV) && defined(USEIFADDR)
1204 afsi_SetServerIPRank(struct srvAddr *sa, struct in_ifaddr *ifa)
1206 struct sockaddr_in *sin;
1209 if ((ntohl(sa->sa_ip) & ifa->ia_netmask) == ifa->ia_net) {
1210 if ((ntohl(sa->sa_ip) & ifa->ia_subnetmask) == ifa->ia_subnet) {
1212 if (SA2ULONG(sin) == ntohl(sa->sa_ip)) { /* ie, ME!!! */
1213 sa->sa_iprank = TOPR;
1215 t = HI + ifa->ia_ifp->if_metric; /* case #2 */
1216 if (sa->sa_iprank > t)
1220 t = MED + ifa->ia_ifp->if_metric; /* case #3 */
1221 if (sa->sa_iprank > t)
1225 #ifdef IFF_POINTTOPOINT
1226 /* check for case #4 -- point-to-point link */
1227 if ((ifa->ia_ifp->if_flags & IFF_POINTOPOINT)
1228 && (SA2ULONG(IA_DST(ifa)) == ntohl(sa->sa_ip))) {
1229 if (ifa->ia_ifp->if_metric >= (MAXDEFRANK - MED) / PPWEIGHT)
1232 t = MED + (PPWEIGHT << ifa->ia_ifp->if_metric);
1233 if (sa->sa_iprank > t)
1236 #endif /* IFF_POINTTOPOINT */
1238 #endif /*(!defined(AFS_SUN5_ENV)) && defined(USEIFADDR) */
1239 #if defined(AFS_DARWIN_ENV) && defined(USEIFADDR)
1241 #define afs_min(A,B) ((A)<(B)) ? (A) : (B)
1244 afsi_SetServerIPRank(struct srvAddr *sa, rx_ifaddr_t ifa)
1246 struct sockaddr sout;
1247 struct sockaddr_in *sin;
1250 afs_uint32 subnetmask, myAddr, myNet, myDstaddr, mySubnet, netMask;
1251 afs_uint32 serverAddr;
1253 if (rx_ifaddr_address_family(ifa) != AF_INET)
1255 t = rx_ifaddr_address(ifa, &sout, sizeof(sout));
1257 sin = (struct sockaddr_in *)&sout;
1258 myAddr = ntohl(sin->sin_addr.s_addr); /* one of my IP addr in host order */
1262 serverAddr = ntohl(sa->sa_ip); /* server's IP addr in host order */
1263 t = rx_ifaddr_netmask(ifa, &sout, sizeof(sout));
1265 sin = (struct sockaddr_in *)&sout;
1266 subnetmask = ntohl(sin->sin_addr.s_addr); /* subnet mask in host order */
1270 t = rx_ifaddr_dstaddress(ifa, &sout, sizeof(sout));
1272 sin = (struct sockaddr_in *)&sout;
1273 myDstaddr = sin->sin_addr.s_addr;
1278 if (IN_CLASSA(myAddr))
1279 netMask = IN_CLASSA_NET;
1280 else if (IN_CLASSB(myAddr))
1281 netMask = IN_CLASSB_NET;
1282 else if (IN_CLASSC(myAddr))
1283 netMask = IN_CLASSC_NET;
1287 myNet = myAddr & netMask;
1288 mySubnet = myAddr & subnetmask;
1290 if ((serverAddr & netMask) == myNet) {
1291 if ((serverAddr & subnetmask) == mySubnet) {
1292 if (serverAddr == myAddr) { /* same machine */
1293 sa->sa_iprank = afs_min(sa->sa_iprank, TOPR);
1294 } else { /* same subnet */
1295 sa->sa_iprank = afs_min(sa->sa_iprank, HI + rx_ifnet_metric(rx_ifaddr_ifnet(ifa)));
1297 } else { /* same net */
1298 sa->sa_iprank = afs_min(sa->sa_iprank, MED + rx_ifnet_metric(rx_ifaddr_ifnet(ifa)));
1301 #ifdef IFF_POINTTOPOINT
1302 /* check for case #4 -- point-to-point link */
1303 if ((rx_ifnet_flags(rx_ifaddr_ifnet(ifa)) & IFF_POINTOPOINT)
1304 && (myDstaddr == serverAddr)) {
1305 if (rx_ifnet_metric(rx_ifaddr_ifnet(ifa)) >= (MAXDEFRANK - MED) / PPWEIGHT)
1308 t = MED + (PPWEIGHT << rx_ifnet_metric(rx_ifaddr_ifnet(ifa)));
1309 if (sa->sa_iprank > t)
1312 #endif /* IFF_POINTTOPOINT */
1314 #endif /*(!defined(AFS_SUN5_ENV)) && defined(USEIFADDR) */
1315 #endif /* else AFS_USERSPACE_IP_ADDR */
1317 #ifdef AFS_SGI62_ENV
1319 afsi_enum_set_rank(struct hashbucket *h, caddr_t mkey, caddr_t arg1,
1322 afsi_SetServerIPRank((struct srvAddr *)arg1, (struct in_ifaddr *)h);
1323 return 0; /* Never match, so we enumerate everyone */
1325 #endif /* AFS_SGI62_ENV */
1327 afs_SetServerPrefs(struct srvAddr *sa)
1329 #if defined(AFS_USERSPACE_IP_ADDR)
1333 for (i = 0; i < afs_cb_interface.numberOfInterfaces; i++) {
1334 afsi_SetServerIPRank(sa, afs_cb_interface.addr_in[i],
1335 afs_cb_interface.subnetmask[i]);
1337 #else /* AFS_USERSPACE_IP_ADDR */
1338 #if defined(AFS_SUN5_ENV)
1339 #ifdef AFS_SUN510_ENV
1342 extern struct ill_s *ill_g_headp;
1343 long *addr = (long *)ill_g_headp;
1347 int subnet, subnetmask, net, netmask;
1351 #ifdef AFS_SUN510_ENV
1352 rw_enter(&afsifinfo_lock, RW_READER);
1354 for (i = 0; (afsifinfo[i].ipaddr != NULL) && (i < ADDRSPERSITE); i++) {
1356 if (IN_CLASSA(afsifinfo[i].ipaddr)) {
1357 netmask = IN_CLASSA_NET;
1358 } else if (IN_CLASSB(afsifinfo[i].ipaddr)) {
1359 netmask = IN_CLASSB_NET;
1360 } else if (IN_CLASSC(afsifinfo[i].ipaddr)) {
1361 netmask = IN_CLASSC_NET;
1365 net = afsifinfo[i].ipaddr & netmask;
1369 if (!rx_IsLoopbackAddr(afsifinfo[i].ipaddr)) { /* ignore loopback */
1373 *addrp++ = afsifinfo[i].ipaddr;
1378 /* XXXXXX Do the individual ip ranking below XXXXX */
1379 if ((sa->sa_ip & netmask) == net) {
1380 if ((sa->sa_ip & subnetmask) == subnet) {
1381 if (afsifinfo[i].ipaddr == sa->sa_ip) { /* ie, ME! */
1382 sa->sa_iprank = TOPR;
1384 sa->sa_iprank = HI + afsifinfo[i].metric; /* case #2 */
1387 sa->sa_iprank = MED + afsifinfo[i].metric; /* case #3 */
1390 sa->sa_iprank = LO + afsifinfo[i].metric; /* case #4 */
1392 /* check for case #5 -- point-to-point link */
1393 if ((afsifinfo[i].flags & IFF_POINTOPOINT)
1394 && (afsifinfo[i].dstaddr == sa->sa_ip)) {
1396 if (afsifinfo[i].metric >= (MAXDEFRANK - MED) / PPWEIGHT)
1397 sa->sa_iprank = MAXDEFRANK;
1399 sa->sa_iprank = MED + (PPWEIGHT << afsifinfo[i].metric);
1404 rw_exit(&afsifinfo_lock);
1406 for (ill = (struct ill_s *)*addr /*ill_g_headp */ ; ill;
1407 ill = ill->ill_next) {
1408 #ifdef AFS_SUN58_ENV
1409 /* Make sure this is an IPv4 ILL */
1413 for (ipif = ill->ill_ipif; ipif; ipif = ipif->ipif_next) {
1414 subnet = ipif->ipif_local_addr & ipif->ipif_net_mask;
1415 subnetmask = ipif->ipif_net_mask;
1417 * Generate the local net using the local address and
1418 * whate we know about Class A, B and C networks.
1420 if (IN_CLASSA(ipif->ipif_local_addr)) {
1421 netmask = IN_CLASSA_NET;
1422 } else if (IN_CLASSB(ipif->ipif_local_addr)) {
1423 netmask = IN_CLASSB_NET;
1424 } else if (IN_CLASSC(ipif->ipif_local_addr)) {
1425 netmask = IN_CLASSC_NET;
1429 net = ipif->ipif_local_addr & netmask;
1432 if (!rx_IsLoopbackAddr(ipif->ipif_local_addr)) { /* ignore loopback */
1436 *addrp++ = ipif->ipif_local_addr;
1441 /* XXXXXX Do the individual ip ranking below XXXXX */
1442 if ((sa->sa_ip & netmask) == net) {
1443 if ((sa->sa_ip & subnetmask) == subnet) {
1444 if (ipif->ipif_local_addr == sa->sa_ip) { /* ie, ME! */
1445 sa->sa_iprank = TOPR;
1447 sa->sa_iprank = HI + ipif->ipif_metric; /* case #2 */
1450 sa->sa_iprank = MED + ipif->ipif_metric; /* case #3 */
1453 sa->sa_iprank = LO + ipif->ipif_metric; /* case #4 */
1455 /* check for case #5 -- point-to-point link */
1456 if ((ipif->ipif_flags & IFF_POINTOPOINT)
1457 && (ipif->ipif_pp_dst_addr == sa->sa_ip)) {
1459 if (ipif->ipif_metric >= (MAXDEFRANK - MED) / PPWEIGHT)
1460 sa->sa_iprank = MAXDEFRANK;
1462 sa->sa_iprank = MED + (PPWEIGHT << ipif->ipif_metric);
1467 #endif /* AFS_SUN510_ENV */
1470 rx_ifnet_t ifn = NULL;
1471 struct in_ifaddr *ifad = (struct in_ifaddr *)0;
1472 struct sockaddr_in *sin;
1475 #ifdef notdef /* clean up, remove this */
1476 for (ifn = ifnet; ifn != NULL; ifn = ifn->if_next) {
1477 for (ifad = ifn->if_addrlist; ifad != NULL; ifad = ifad->ifa_next) {
1478 if ((IFADDR2SA(ifad)->sa_family == AF_INET)
1479 && !(ifn->if_flags & IFF_LOOPBACK)) {
1484 ((struct sockaddr_in *)IFADDR2SA(ifad))->sin_addr.
1493 ifn = rxi_FindIfnet(sa->sa_ip, &ifad);
1495 if (ifn) { /* local, more or less */
1497 if (ifn->if_flags & IFF_LOOPBACK) {
1498 sa->sa_iprank = TOPR;
1501 #endif /* IFF_LOOPBACK */
1502 sin = (struct sockaddr_in *)IA_SIN(ifad);
1503 if (SA2ULONG(sin) == sa->sa_ip) {
1504 sa->sa_iprank = TOPR;
1507 #ifdef IFF_BROADCAST
1508 if (ifn->if_flags & IFF_BROADCAST) {
1509 if (sa->sa_ip == (sa->sa_ip & SA2ULONG(IA_BROAD(ifad)))) {
1514 #endif /* IFF_BROADCAST */
1515 #ifdef IFF_POINTOPOINT
1516 if (ifn->if_flags & IFF_POINTOPOINT) {
1517 if (sa->sa_ip == SA2ULONG(IA_DST(ifad))) {
1518 if (ifn->if_metric > 4) {
1522 sa->sa_iprank = ifn->if_metric;
1525 #endif /* IFF_POINTOPOINT */
1526 sa->sa_iprank += MED + ifn->if_metric; /* couldn't find anything better */
1528 #else /* USEIFADDR */
1532 #ifdef AFS_SGI62_ENV
1533 (void)hash_enum(&hashinfo_inaddr, afsi_enum_set_rank, HTF_INET, NULL,
1534 (caddr_t) sa, NULL);
1535 #elif defined(AFS_DARWIN80_ENV)
1543 if (!ifnet_list_get(AF_INET, &ifns, &count)) {
1544 for (m = 0; m < count; m++) {
1545 if (!ifnet_get_address_list(ifns[m], &ifads)) {
1546 for (j = 0; ifads[j] != NULL && cnt < ADDRSPERSITE; j++) {
1547 afsi_SetServerIPRank(sa, ifads[j]);
1550 ifnet_free_address_list(ifads);
1553 ifnet_list_free(ifns);
1556 #elif defined(AFS_DARWIN_ENV)
1560 TAILQ_FOREACH(ifn, &ifnet, if_link) {
1561 TAILQ_FOREACH(ifa, &ifn->if_addrhead, ifa_link) {
1562 afsi_SetServerIPRank(sa, ifa);
1564 #elif defined(AFS_FBSD_ENV)
1566 struct in_ifaddr *ifa;
1567 TAILQ_FOREACH(ifa, &in_ifaddrhead, ia_link) {
1568 afsi_SetServerIPRank(sa, ifa);
1570 #elif defined(AFS_OBSD_ENV)
1572 extern struct in_ifaddrhead in_ifaddr;
1573 struct in_ifaddr *ifa;
1574 for (ifa = in_ifaddr.tqh_first; ifa; ifa = ifa->ia_list.tqe_next)
1575 afsi_SetServerIPRank(sa, ifa);
1577 #elif defined(AFS_NBSD40_ENV)
1579 extern struct in_ifaddrhead in_ifaddrhead;
1580 struct in_ifaddr *ifa;
1581 for (ifa = in_ifaddrhead.tqh_first; ifa; ifa = ifa->ia_list.tqe_next)
1582 afsi_SetServerIPRank(sa, ifa);
1586 struct in_ifaddr *ifa;
1587 for (ifa = in_ifaddr; ifa; ifa = ifa->ia_next) {
1588 afsi_SetServerIPRank(sa, ifa);
1591 #endif /* USEIFADDR */
1595 #endif /* AFS_SUN5_ENV */
1596 #endif /* else AFS_USERSPACE_IP_ADDR */
1598 sa->sa_iprank += afs_randomMod15();
1601 } /* afs_SetServerPrefs */
1609 /* afs_FlushServer()
1610 * The addresses on this server struct has changed in some way and will
1611 * clean up all other structures that may reference it.
1612 * The afs_xserver and afs_xsrvAddr locks are assumed taken.
1615 afs_FlushServer(struct server *srvp)
1618 struct server *ts, **pts;
1620 /* Find any volumes residing on this server and flush their state */
1621 afs_ResetVolumes(srvp);
1623 /* Flush all callbacks in the all vcaches for this specific server */
1624 afs_FlushServerCBs(srvp);
1626 /* Remove all the callbacks structs */
1628 struct afs_cbr *cb, *cbnext;
1630 ObtainWriteLock(&afs_xvcb, 300);
1631 for (cb = srvp->cbrs; cb; cb = cbnext) {
1634 } srvp->cbrs = (struct afs_cbr *)0;
1635 ReleaseWriteLock(&afs_xvcb);
1638 /* If no more srvAddr structs hanging off of this server struct,
1642 /* Remove the server structure from the cell list - if there */
1643 afs_RemoveCellEntry(srvp);
1645 /* Remove from the afs_servers hash chain */
1646 for (i = 0; i < NSERVERS; i++) {
1647 for (pts = &(afs_servers[i]), ts = *pts; ts;
1648 pts = &(ts->next), ts = *pts) {
1656 *pts = ts->next; /* Found it. Remove it */
1657 afs_osi_Free(ts, sizeof(struct server)); /* Free it */
1663 /* afs_RemoveSrvAddr()
1664 * This removes a SrvAddr structure from its server structure.
1665 * The srvAddr struct is not free'd because it connections may still
1666 * be open to it. It is up to the calling process to make sure it
1667 * remains connected to a server struct.
1668 * The afs_xserver and afs_xsrvAddr locks are assumed taken.
1669 * It is not removed from the afs_srvAddrs hash chain.
1672 afs_RemoveSrvAddr(struct srvAddr *sap)
1674 struct srvAddr **psa, *sa;
1681 /* Find the srvAddr in the server's list and remove it */
1682 for (psa = &(srv->addr), sa = *psa; sa; psa = &(sa->next_sa), sa = *psa) {
1690 /* Flush the server struct since it's IP address has changed */
1691 afs_FlushServer(srv);
1695 /* afs_GetCapabilities
1696 * Try and retrieve capabilities of a given file server. Carps on actual
1697 * failure. Servers are not expected to support this RPC. */
1699 afs_GetCapabilities(struct server *ts)
1701 Capabilities caps = {0, NULL};
1702 struct vrequest treq;
1703 struct afs_conn *tc;
1704 struct unixuser *tu;
1707 if ( !ts || !ts->cell )
1709 if ( !afs_osi_credp )
1712 if ((code = afs_InitReq(&treq, afs_osi_credp)))
1714 tu = afs_GetUser(treq.uid, ts->cell->cellNum, SHARED_LOCK);
1717 tc = afs_ConnBySA(ts->addr, ts->cell->fsport, ts->cell->cellNum, tu, 0, 1,
1721 /* InitCallBackStateN, triggered by our RPC, may need this */
1722 ReleaseWriteLock(&afs_xserver);
1723 code = RXAFS_GetCapabilities(tc->id, &caps);
1724 ObtainWriteLock(&afs_xserver, 723);
1725 afs_PutConn(tc, SHARED_LOCK);
1726 if ( code && code != RXGEN_OPCODE ) {
1727 afs_warn("RXAFS_GetCapabilities failed with code %d\n", code);
1728 /* better not be anything to free. we failed! */
1732 ts->flags |= SCAPS_KNOWN;
1734 if ( caps.Capabilities_len > 0 ) {
1735 ts->capabilities = caps.Capabilities_val[0];
1736 xdr_free((xdrproc_t)xdr_Capabilities, &caps);
1737 caps.Capabilities_len = 0;
1738 caps.Capabilities_val = NULL;
1744 * Return an updated and properly initialized server structure
1745 * corresponding to the server ID, cell, and port specified.
1746 * If one does not exist, then one will be created.
1747 * aserver and aport must be in NET byte order.
1750 afs_GetServer(afs_uint32 * aserverp, afs_int32 nservers, afs_int32 acell,
1751 u_short aport, afs_int32 locktype, afsUUID * uuidp,
1752 afs_int32 addr_uniquifier)
1754 struct server *oldts = 0, *ts, *newts, *orphts = 0;
1755 struct srvAddr *oldsa, *newsa, *nextsa, *orphsa;
1757 afs_int32 iphash, k, srvcount = 0;
1758 unsigned int srvhash;
1760 AFS_STATCNT(afs_GetServer);
1762 ObtainSharedLock(&afs_xserver, 13);
1764 /* Check if the server struct exists and is up to date */
1767 panic("afs_GetServer: incorect count of servers");
1768 ObtainReadLock(&afs_xsrvAddr);
1769 ts = afs_FindServer(aserverp[0], aport, NULL, locktype);
1770 ReleaseReadLock(&afs_xsrvAddr);
1771 if (ts && !(ts->flags & SRVR_MULTIHOMED)) {
1772 /* Found a server struct that is not multihomed and has the
1773 * IP address associated with it. A correct match.
1775 ReleaseSharedLock(&afs_xserver);
1780 panic("afs_GetServer: incorrect count of servers");
1781 ts = afs_FindServer(0, aport, uuidp, locktype);
1782 if (ts && (ts->sr_addr_uniquifier == addr_uniquifier) && ts->addr) {
1783 /* Found a server struct that is multihomed and same
1784 * uniqufier (same IP addrs). The above if statement is the
1785 * same as in InstallUVolumeEntry().
1787 ReleaseSharedLock(&afs_xserver);
1791 oldts = ts; /* Will reuse if same uuid */
1794 UpgradeSToWLock(&afs_xserver, 36);
1795 ObtainWriteLock(&afs_xsrvAddr, 116);
1797 srvcount = afs_totalServers;
1799 /* Reuse/allocate a new server structure */
1803 newts = afs_osi_Alloc(sizeof(struct server));
1805 panic("malloc of server struct");
1807 memset(newts, 0, sizeof(struct server));
1809 /* Add the server struct to the afs_servers[] hash chain */
1811 (uuidp ? (afs_uuid_hash(uuidp) % NSERVERS) : SHash(aserverp[0]));
1812 newts->next = afs_servers[srvhash];
1813 afs_servers[srvhash] = newts;
1816 /* Initialize the server structure */
1817 if (uuidp) { /* Multihomed */
1818 newts->sr_uuid = *uuidp;
1819 newts->sr_addr_uniquifier = addr_uniquifier;
1820 newts->flags |= SRVR_MULTIHOMED;
1823 newts->cell = afs_GetCell(acell, 0);
1825 fsport = (newts->cell ? newts->cell->fsport : AFS_FSPORT);
1827 /* For each IP address we are registering */
1828 for (k = 0; k < nservers; k++) {
1829 iphash = SHash(aserverp[k]);
1831 /* Check if the srvAddr structure already exists. If so, remove
1832 * it from its server structure and add it to the new one.
1834 for (oldsa = afs_srvAddrs[iphash]; oldsa; oldsa = oldsa->next_bkt) {
1835 if ((oldsa->sa_ip == aserverp[k]) && (oldsa->sa_portal == aport))
1838 if (oldsa && (oldsa->server != newts)) {
1839 afs_RemoveSrvAddr(oldsa); /* Remove from its server struct */
1840 oldsa->next_sa = newts->addr; /* Add to the new server struct */
1841 newts->addr = oldsa;
1844 /* Reuse/allocate a new srvAddr structure */
1848 newsa = afs_osi_Alloc(sizeof(struct srvAddr));
1850 panic("malloc of srvAddr struct");
1851 afs_totalSrvAddrs++;
1852 memset(newsa, 0, sizeof(struct srvAddr));
1854 /* Add the new srvAddr to the afs_srvAddrs[] hash chain */
1855 newsa->next_bkt = afs_srvAddrs[iphash];
1856 afs_srvAddrs[iphash] = newsa;
1858 /* Hang off of the server structure */
1859 newsa->next_sa = newts->addr;
1860 newts->addr = newsa;
1862 /* Initialize the srvAddr Structure */
1863 newsa->sa_ip = aserverp[k];
1864 newsa->sa_portal = aport;
1867 /* Update the srvAddr Structure */
1868 newsa->server = newts;
1869 if (newts->flags & SRVR_ISDOWN)
1870 newsa->sa_flags |= SRVADDR_ISDOWN;
1872 newsa->sa_flags |= SRVADDR_MH;
1874 newsa->sa_flags &= ~SRVADDR_MH;
1876 /* Compute preference values and resort */
1877 if (!newsa->sa_iprank) {
1878 afs_SetServerPrefs(newsa); /* new server rank */
1881 afs_SortOneServer(newts); /* Sort by rank */
1883 /* If we reused the server struct, remove any of its srvAddr
1884 * structs that will no longer be associated with this server.
1886 if (oldts) { /* reused the server struct */
1887 for (orphsa = newts->addr; orphsa; orphsa = nextsa) {
1888 nextsa = orphsa->next_sa;
1889 for (k = 0; k < nservers; k++) {
1890 if (orphsa->sa_ip == aserverp[k])
1891 break; /* belongs */
1894 continue; /* belongs */
1896 /* Have a srvAddr struct. Now get a server struct (if not already) */
1898 orphts = afs_osi_Alloc(sizeof(struct server));
1900 panic("malloc of lo server struct");
1901 memset(orphts, 0, sizeof(struct server));
1904 /* Add the orphaned server to the afs_servers[] hash chain.
1905 * Its iphash does not matter since we never look up the server
1906 * in the afs_servers table by its ip address (only by uuid -
1907 * which this has none).
1909 iphash = SHash(aserverp[k]);
1910 orphts->next = afs_servers[iphash];
1911 afs_servers[iphash] = orphts;
1914 orphts->cell = afs_GetCell(acell, 0);
1917 /* Hang the srvAddr struct off of the server structure. The server
1918 * may have multiple srvAddrs, but it won't be marked multihomed.
1920 afs_RemoveSrvAddr(orphsa); /* remove */
1921 orphsa->next_sa = orphts->addr; /* hang off server struct */
1922 orphts->addr = orphsa;
1923 orphsa->server = orphts;
1924 orphsa->sa_flags |= SRVADDR_NOUSE; /* flag indicating not in use */
1925 orphsa->sa_flags &= ~SRVADDR_MH; /* Not multihomed */
1929 srvcount = afs_totalServers - srvcount; /* # servers added and removed */
1931 struct afs_stats_SrvUpDownInfo *upDownP;
1932 /* With the introduction of this new record, we need to adjust the
1933 * proper individual & global server up/down info.
1935 upDownP = GetUpDownStats(newts);
1936 upDownP->numTtlRecords += srvcount;
1937 afs_stats_cmperf.srvRecords += srvcount;
1938 if (afs_stats_cmperf.srvRecords > afs_stats_cmperf.srvRecordsHWM)
1939 afs_stats_cmperf.srvRecordsHWM = afs_stats_cmperf.srvRecords;
1942 ReleaseWriteLock(&afs_xsrvAddr);
1944 if ( aport == AFS_FSPORT && !(newts->flags & SCAPS_KNOWN))
1945 afs_GetCapabilities(newts);
1947 ReleaseWriteLock(&afs_xserver);
1949 } /* afs_GetServer */
1952 afs_ActivateServer(struct srvAddr *sap)
1954 osi_timeval_t currTime; /*Filled with current time */
1955 osi_timeval_t *currTimeP; /*Ptr to above */
1956 struct afs_stats_SrvUpDownInfo *upDownP; /*Ptr to up/down info record */
1957 struct server *aserver = sap->server;
1959 if (!(aserver->flags & AFS_SERVER_FLAG_ACTIVATED)) {
1961 * This server record has not yet been activated. Go for it,
1962 * recording its ``birth''.
1964 aserver->flags |= AFS_SERVER_FLAG_ACTIVATED;
1965 currTimeP = &currTime;
1966 osi_GetuTime(currTimeP);
1967 aserver->activationTime = currTime.tv_sec;
1968 upDownP = GetUpDownStats(aserver);
1969 if (aserver->flags & SRVR_ISDOWN) {
1970 upDownP->numDownRecords++;
1972 upDownP->numUpRecords++;
1973 upDownP->numRecordsNeverDown++;
1979 afs_RemoveAllConns(void)
1982 struct server *ts, *nts;
1984 struct afs_conn *tc, *ntc;
1986 ObtainReadLock(&afs_xserver);
1987 ObtainWriteLock(&afs_xconn, 1001);
1989 /*printf("Destroying connections ... ");*/
1990 for (i = 0; i < NSERVERS; i++) {
1991 for (ts = afs_servers[i]; ts; ts = nts) {
1993 for (sa = ts->addr; sa; sa = sa->next_sa) {
1999 rx_DestroyConnection(tc->id);
2001 afs_osi_Free(tc, sizeof(struct afs_conn));
2009 /*printf("done\n");*/
2011 ReleaseWriteLock(&afs_xconn);
2012 ReleaseReadLock(&afs_xserver);
2017 afs_MarkAllServersUp(void)
2023 ObtainWriteLock(&afs_xserver, 721);
2024 ObtainWriteLock(&afs_xsrvAddr, 722);
2025 for (i = 0; i< NSERVERS; i++) {
2026 for (ts = afs_servers[i]; ts; ts = ts->next) {
2027 for (sa = ts->addr; sa; sa = sa->next_sa) {
2028 afs_MarkServerUpOrDown(sa, 0);
2032 ReleaseWriteLock(&afs_xsrvAddr);
2033 ReleaseWriteLock(&afs_xserver);