Windows: No network, no probe
[openafs.git] / src / WINNT / afsd / cm_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 #include <afsconfig.h>
11 #include <afs/param.h>
12 #include <roken.h>
13
14 #include <afs/stds.h>
15
16 #include <windows.h>
17 #include <winsock2.h>
18 #include <nb30.h>
19 #include <stdlib.h>
20 #include <malloc.h>
21 #include <string.h>
22
23 #include "afsd.h"
24 #include <WINNT\syscfg.h>
25 #include <WINNT/afsreg.h>
26 #include <osi.h>
27 #include <rx/rx.h>
28 #include <math.h>
29
30 osi_rwlock_t cm_serverLock;
31 osi_rwlock_t cm_syscfgLock;
32
33 cm_server_t *cm_serversAllFirstp = NULL;
34 cm_server_t *cm_serversAllLastp = NULL;
35
36 afs_uint32   cm_numFileServers = 0;
37 afs_uint32   cm_numVldbServers = 0;
38
39 void
40 cm_ForceNewConnectionsAllServers(void)
41 {
42     cm_server_t *tsp;
43
44     lock_ObtainRead(&cm_serverLock);
45     for (tsp = cm_serversAllFirstp;
46          tsp;
47          tsp = (cm_server_t *)osi_QNext(&tsp->allq)) {
48         cm_GetServerNoLock(tsp);
49         lock_ReleaseRead(&cm_serverLock);
50         cm_ForceNewConnections(tsp);
51         lock_ObtainRead(&cm_serverLock);
52         cm_PutServerNoLock(tsp);
53     }
54     lock_ReleaseRead(&cm_serverLock);
55 }
56
57 void
58 cm_ServerClearRPCStats(void) {
59     cm_server_t *tsp;
60     afs_uint16 port;
61
62     lock_ObtainRead(&cm_serverLock);
63     for (tsp = cm_serversAllFirstp;
64          tsp;
65          tsp = (cm_server_t *)osi_QNext(&tsp->allq)) {
66         switch (tsp->type) {
67         case CM_SERVER_VLDB:
68             port = htons(7003);
69             rx_ClearPeerRPCStats(opcode_VL_ProbeServer>>32, tsp->addr.sin_addr.s_addr, port);
70             break;
71         case CM_SERVER_FILE:
72             port = htons(7000);
73             rx_ClearPeerRPCStats(opcode_RXAFS_GetCapabilities>>32, tsp->addr.sin_addr.s_addr, port);
74             rx_ClearPeerRPCStats(opcode_RXAFS_GetTime>>32, tsp->addr.sin_addr.s_addr, port);
75             break;
76         }
77     }
78     lock_ReleaseRead(&cm_serverLock);
79 }
80
81 /*
82  * lock_ObtainMutex must be held prior to calling
83  * this function.
84  */
85 afs_int32
86 cm_RankServer(cm_server_t * tsp)
87 {
88     afs_int32 code = 0; /* start with "success" */
89     struct rx_debugPeer tpeer;
90     struct rx_peer * rxPeer;
91     afs_uint16 port;
92     afs_uint64 newRank;
93     afs_uint64 perfRank = 0;
94     afs_uint64 rtt = 0;
95     double log_rtt;
96
97     int isDown = (tsp->flags & CM_SERVERFLAG_DOWN);
98     void *peerRpcStats = NULL;
99     afs_uint64 opcode = 0;
100
101     switch(tsp->type) {
102         case CM_SERVER_VLDB:
103             port = htons(7003);
104             opcode = opcode_VL_ProbeServer;
105             break;
106         case CM_SERVER_FILE:
107             port = htons(7000);
108             opcode = opcode_RXAFS_GetCapabilities;
109             break;
110         default:
111             return -1;
112     }
113
114     cm_SetServerIPRank(tsp);
115
116     if (isDown) {
117         newRank = 0xFFFF;
118     } else {
119         /*
120         * There are three potential components to the ranking:
121         *  1. Any administrative set preference whether it be
122         *     via "fs setserverprefs", registry or dns.
123         *
124         *  2. Network subnet mask comparison.
125         *
126         *  3. Performance data.
127         *
128         * If there is an administrative rank, that is the
129         * the primary factor.  If not the primary factor
130         * is the network ranking.
131         */
132
133         code = rx_GetLocalPeers(tsp->addr.sin_addr.s_addr, port, &tpeer);
134         if (code == 0) {
135             peerRpcStats = rx_CopyPeerRPCStats(opcode, tsp->addr.sin_addr.s_addr, port);
136             if (peerRpcStats == NULL && tsp->type == CM_SERVER_FILE)
137                 peerRpcStats = rx_CopyPeerRPCStats(opcode_RXAFS_GetTime, tsp->addr.sin_addr.s_addr, port);
138             if (peerRpcStats) {
139                 afs_uint64 execTimeSum = _8THMSEC(RPCOpStat_ExecTimeSum(peerRpcStats));
140                 afs_uint64 queueTimeSum = _8THMSEC(RPCOpStat_QTimeSum(peerRpcStats));
141                 afs_uint64 numCalls = RPCOpStat_NumCalls(peerRpcStats);
142
143                 if (numCalls > 0)
144                     rtt = (execTimeSum - queueTimeSum) / numCalls;
145
146                 rx_ReleaseRPCStats(peerRpcStats);
147             }
148
149             if (rtt == 0 && tpeer.rtt) {
150                 /* rtt is ms/8 */
151                 rtt = tpeer.rtt;
152             }
153
154             if (rtt > 0) {
155                 log_rtt = log(rtt);
156                 perfRank += (6000 * log_rtt / 5000) * 5000;
157
158                 if (tsp->type == CM_SERVER_FILE) {
159                     /* give an edge to servers with high congestion windows */
160                     perfRank -= (tpeer.cwind - 1)* 15;
161                 }
162             }
163         }
164
165         if (tsp->adminRank) {
166             newRank = tsp->adminRank * 0.8;
167             newRank += tsp->ipRank * 0.2;
168         } else {
169             newRank = tsp->ipRank;
170         }
171         if (perfRank) {
172             newRank *= 0.9;
173             newRank += perfRank * 0.1;
174         }
175         newRank += (rand() & 0x000f); /* randomize */
176
177         if (newRank > 0xFFFF)
178             osi_Log1(afsd_logp, "new server rank %I64u exceeds 0xFFFF", newRank);
179
180         /*
181          * If the ranking changes by more than the randomization
182          * factor, update the server reference lists.
183          */
184         if (abs(newRank - tsp->activeRank) > 0xf) {
185             tsp->activeRank = newRank;
186
187             lock_ReleaseMutex(&tsp->mx);
188             switch (tsp->type) {
189             case CM_SERVER_FILE:
190                 /*
191                  * find volumes which might have RO copy
192                  * on server and change the ordering of
193                  * their RO list
194                  */
195                 cm_ChangeRankVolume(tsp);
196                 break;
197             case CM_SERVER_VLDB:
198                 /* set preferences for an existing vlserver */
199                 cm_ChangeRankCellVLServer(tsp);
200                 break;
201             }
202             lock_ObtainMutex(&tsp->mx);
203         }
204     }
205
206     return code;
207 }
208
209 static void
210 cm_MarkServerDown(cm_server_t *tsp, afs_int32 code, int wasDown)
211 {
212
213     /* mark server as down */
214     if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
215         _InterlockedOr(&tsp->flags, CM_SERVERFLAG_DOWN);
216         tsp->downTime = time(NULL);
217     }
218     if (code != VRESTARTING) {
219         lock_ReleaseMutex(&tsp->mx);
220         cm_ForceNewConnections(tsp);
221         lock_ObtainMutex(&tsp->mx);
222     }
223     /* Now update the volume status if necessary */
224     if (!wasDown) {
225         if (tsp->type == CM_SERVER_FILE) {
226             cm_server_vols_t * tsrvp;
227             cm_volume_t * volp;
228             int i;
229             cm_req_t req;
230
231             for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
232                 for (i=0; i<NUM_SERVER_VOLS; i++) {
233                     if (tsrvp->ids[i] != 0) {
234                         cm_InitReq(&req);
235
236                         lock_ReleaseMutex(&tsp->mx);
237                         code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i],
238                                                  cm_rootUserp, &req,
239                                                  CM_GETVOL_FLAG_NO_LRU_UPDATE,
240                                                  &volp);
241                         lock_ObtainMutex(&tsp->mx);
242                         if (code == 0) {
243                             cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
244                             cm_PutVolume(volp);
245                         }
246                     }
247                 }
248             }
249         }
250         cm_RankServer(tsp);
251     }
252 }
253
254 void
255 cm_PingServer(cm_server_t *tsp)
256 {
257     long code;
258     int wasDown = 0;
259     cm_conn_t *connp;
260     struct rx_connection * rxconnp;
261     Capabilities caps = {0, 0};
262     char hoststr[16];
263     cm_req_t req;
264
265     lock_ObtainMutex(&tsp->mx);
266     if (tsp->flags & CM_SERVERFLAG_PINGING) {
267         tsp->waitCount++;
268         osi_SleepM((LONG_PTR)tsp, &tsp->mx);
269         lock_ObtainMutex(&tsp->mx);
270         tsp->waitCount--;
271         if (tsp->waitCount == 0)
272             _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_PINGING);
273         else
274             osi_Wakeup((LONG_PTR)tsp);
275         lock_ReleaseMutex(&tsp->mx);
276         return;
277     }
278     _InterlockedOr(&tsp->flags, CM_SERVERFLAG_PINGING);
279     wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
280     afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
281     lock_ReleaseMutex(&tsp->mx);
282
283     if (cm_noIPAddr > 0)
284         code = cm_ConnByServer(tsp, cm_rootUserp, FALSE, &connp);
285     else
286         code = RX_CALL_DEAD;    /* No network */
287     if (code == 0) {
288         /* now call the appropriate ping call.  Drop the timeout if
289         * the server is known to be down, so that we don't waste a
290         * lot of time retiming out down servers.
291         */
292
293         osi_Log4(afsd_logp, "cm_PingServer server %s (%s) was %s with caps 0x%x",
294                   osi_LogSaveString(afsd_logp, hoststr),
295                   tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
296                   wasDown ? "down" : "up",
297                   tsp->capabilities);
298
299         rxconnp = cm_GetRxConn(connp);
300         if (wasDown)
301             rx_SetConnHardDeadTime(rxconnp, 10);
302         if (tsp->type == CM_SERVER_VLDB) {
303             code = VL_ProbeServer(rxconnp);
304         }
305         else {
306             /* file server */
307             code = RXAFS_GetCapabilities(rxconnp, &caps);
308         }
309         if (wasDown)
310             rx_SetConnHardDeadTime(rxconnp, HardDeadtimeout);
311         rx_PutConnection(rxconnp);
312         cm_PutConn(connp);
313     }   /* got an unauthenticated connection to this server */
314
315     lock_ObtainMutex(&tsp->mx);
316     if (code >= 0 || code == RXGEN_OPCODE || code == RX_CALL_BUSY) {
317         /* mark server as up */
318         _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_DOWN);
319         tsp->downTime = 0;
320
321         /* we currently handle 32-bits of capabilities */
322         if (code != RXGEN_OPCODE && code != RX_CALL_BUSY &&
323             caps.Capabilities_len > 0) {
324             tsp->capabilities = caps.Capabilities_val[0];
325             xdr_free((xdrproc_t) xdr_Capabilities, &caps);
326             caps.Capabilities_len = 0;
327             caps.Capabilities_val = 0;
328         } else {
329             tsp->capabilities = 0;
330         }
331
332         osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is up with caps 0x%x",
333                   osi_LogSaveString(afsd_logp, hoststr),
334                   tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
335                   tsp->capabilities);
336
337         /* Now update the volume status if necessary */
338         if (wasDown) {
339             cm_server_vols_t * tsrvp;
340             cm_volume_t * volp;
341             int i;
342
343             for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
344                 for (i=0; i<NUM_SERVER_VOLS; i++) {
345                     if (tsrvp->ids[i] != 0) {
346                         cm_InitReq(&req);
347
348                         lock_ReleaseMutex(&tsp->mx);
349                         code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
350                                                 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
351                         lock_ObtainMutex(&tsp->mx);
352                         if (code == 0) {
353                             cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
354                             cm_PutVolume(volp);
355                         }
356                     }
357                 }
358             }
359             cm_RankServer(tsp);
360         }
361     } else {
362         cm_MarkServerDown(tsp, code, wasDown);
363
364         osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is down with caps 0x%x",
365                   osi_LogSaveString(afsd_logp, hoststr),
366                   tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
367                   tsp->capabilities);
368     }
369
370     if (tsp->waitCount == 0)
371         _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_PINGING);
372     else
373         osi_Wakeup((LONG_PTR)tsp);
374     lock_ReleaseMutex(&tsp->mx);
375 }
376
377 void
378 cm_RankUpServers()
379 {
380     cm_server_t * tsp;
381
382     lock_ObtainRead(&cm_serverLock);
383     for (tsp = cm_serversAllFirstp;
384          tsp;
385          tsp = (cm_server_t *)osi_QNext(&tsp->allq)) {
386         cm_GetServerNoLock(tsp);
387         lock_ReleaseRead(&cm_serverLock);
388
389         lock_ObtainMutex(&tsp->mx);
390
391         /* if the server is not down, rank the server */
392         if(!(tsp->flags & CM_SERVERFLAG_DOWN))
393            cm_RankServer(tsp);
394
395         lock_ReleaseMutex(&tsp->mx);
396
397         lock_ObtainRead(&cm_serverLock);
398         cm_PutServerNoLock(tsp);
399     }
400     lock_ReleaseRead(&cm_serverLock);
401 }
402
403 static void cm_CheckServersSingular(afs_uint32 flags, cm_cell_t *cellp)
404 {
405     /* ping all file servers, up or down, with unauthenticated connection,
406      * to find out whether we have all our callbacks from the server still.
407      * Also, ping down VLDBs.
408      */
409     cm_server_t *tsp;
410     int doPing;
411     int isDown;
412     int isFS;
413     int isVLDB;
414
415     lock_ObtainRead(&cm_serverLock);
416     for (tsp = cm_serversAllFirstp;
417          tsp;
418          tsp = (cm_server_t *)osi_QNext(&tsp->allq)) {
419         cm_GetServerNoLock(tsp);
420         lock_ReleaseRead(&cm_serverLock);
421
422         /* now process the server */
423         lock_ObtainMutex(&tsp->mx);
424
425         doPing = 0;
426         isDown = tsp->flags & CM_SERVERFLAG_DOWN;
427         isFS   = tsp->type == CM_SERVER_FILE;
428         isVLDB = tsp->type == CM_SERVER_VLDB;
429
430         /* only do the ping if the cell matches the requested cell, or we're
431          * matching all cells (cellp == NULL), and if we've requested to ping
432          * this type of {up, down} servers.
433          */
434         if ((cellp == NULL || cellp == tsp->cellp) &&
435              ((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
436                (!isDown && (flags & CM_FLAG_CHECKUPSERVERS))) &&
437              ((!(flags & CM_FLAG_CHECKVLDBSERVERS) ||
438                isVLDB && (flags & CM_FLAG_CHECKVLDBSERVERS)) &&
439               (!(flags & CM_FLAG_CHECKFILESERVERS) ||
440                  isFS && (flags & CM_FLAG_CHECKFILESERVERS)))) {
441             doPing = 1;
442         }       /* we're supposed to check this up/down server */
443         lock_ReleaseMutex(&tsp->mx);
444
445         /* at this point, we've adjusted the server state, so do the ping and
446          * adjust things.
447          */
448         if (doPing)
449             cm_PingServer(tsp);
450
451         /* also, run the GC function for connections on all of the
452          * server's connections.
453          */
454         cm_GCConnections(tsp);
455
456         lock_ObtainRead(&cm_serverLock);
457         cm_PutServerNoLock(tsp);
458     }
459     lock_ReleaseRead(&cm_serverLock);
460 }
461
462 static void cm_CheckServersMulti(afs_uint32 flags, cm_cell_t *cellp)
463 {
464     /*
465      * The goal of this function is to probe simultaneously
466      * probe all of the up/down servers (vldb/file) as
467      * specified by flags in the minimum number of RPCs.
468      * Effectively that means use one multi_RXAFS_GetCapabilities()
469      * followed by possibly one multi_RXAFS_GetTime() and
470      * one multi_VL_ProbeServer().
471      *
472      * To make this work we must construct the list of vldb
473      * and file servers that are to be probed as well as the
474      * associated data structures.
475      */
476
477     int srvAddrCount = 0;
478     struct srvAddr **addrs = NULL;
479     cm_conn_t **conns = NULL;
480     struct rx_connection **rxconns = NULL;
481     cm_req_t req;
482     afs_int32 i, nconns = 0, maxconns;
483     afs_int32 *conntimer, *results;
484     Capabilities *caps = NULL;
485     cm_server_t ** serversp, *tsp;
486     afs_uint32 isDown, wasDown;
487     afs_uint32 code;
488     time_t start;
489     char hoststr[16];
490
491     cm_InitReq(&req);
492     maxconns = max(cm_numFileServers,cm_numVldbServers);
493     if (maxconns == 0)
494         return;
495
496     conns = (cm_conn_t **)malloc(maxconns * sizeof(cm_conn_t *));
497     rxconns = (struct rx_connection **)malloc(maxconns * sizeof(struct rx_connection *));
498     conntimer = (afs_int32 *)malloc(maxconns * sizeof (afs_int32));
499     results = (afs_int32 *)malloc(maxconns * sizeof (afs_int32));
500     serversp = (cm_server_t **)malloc(maxconns * sizeof(cm_server_t *));
501     caps = (Capabilities *)malloc(maxconns * sizeof(Capabilities));
502
503     memset(caps, 0, maxconns * sizeof(Capabilities));
504
505     if ((flags & CM_FLAG_CHECKFILESERVERS) ||
506         !(flags & (CM_FLAG_CHECKFILESERVERS|CM_FLAG_CHECKVLDBSERVERS)))
507     {
508         lock_ObtainRead(&cm_serverLock);
509         for (nconns=0, tsp = cm_serversAllFirstp;
510               tsp != NULL && nconns < maxconns;
511               tsp = (cm_server_t *)osi_QNext(&tsp->allq)) {
512             if (tsp->type != CM_SERVER_FILE ||
513                 tsp->cellp == NULL ||           /* SetPref only */
514                 cellp && cellp != tsp->cellp)
515                 continue;
516
517             cm_GetServerNoLock(tsp);
518             lock_ReleaseRead(&cm_serverLock);
519
520             lock_ObtainMutex(&tsp->mx);
521             isDown = tsp->flags & CM_SERVERFLAG_DOWN;
522
523             if ((tsp->flags & CM_SERVERFLAG_PINGING) ||
524                 !((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
525                    (!isDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
526                 lock_ReleaseMutex(&tsp->mx);
527                 lock_ObtainRead(&cm_serverLock);
528                 cm_PutServerNoLock(tsp);
529                 continue;
530             }
531
532             _InterlockedOr(&tsp->flags, CM_SERVERFLAG_PINGING);
533             lock_ReleaseMutex(&tsp->mx);
534
535             serversp[nconns] = tsp;
536             if (cm_noIPAddr > 0)
537                 code = cm_ConnByServer(tsp, cm_rootUserp, FALSE, &conns[nconns]);
538             else
539                 code = RX_CALL_DEAD;
540             if (code) {
541                 if (code == RX_CALL_DEAD) {
542                     lock_ObtainMutex(&tsp->mx);
543                     cm_MarkServerDown(tsp, code, isDown);
544                     lock_ReleaseMutex(&tsp->mx);
545                 }
546                 lock_ObtainRead(&cm_serverLock);
547                 cm_PutServerNoLock(tsp);
548                 continue;
549             }
550             lock_ObtainRead(&cm_serverLock);
551             rxconns[nconns] = cm_GetRxConn(conns[nconns]);
552             if (conntimer[nconns] = (isDown ? 1 : 0))
553                 rx_SetConnHardDeadTime(rxconns[nconns], 10);
554
555             nconns++;
556         }
557         lock_ReleaseRead(&cm_serverLock);
558
559         if (nconns) {
560             /* Perform the multi call */
561             start = time(NULL);
562             multi_Rx(rxconns,nconns)
563             {
564                 multi_RXAFS_GetCapabilities(&caps[multi_i]);
565                 results[multi_i]=multi_error;
566             } multi_End;
567         }
568
569         /* Process results of servers that support RXAFS_GetCapabilities */
570         for (i=0; i<nconns; i++) {
571             if (conntimer[i])
572                 rx_SetConnHardDeadTime(rxconns[i], HardDeadtimeout);
573             rx_PutConnection(rxconns[i]);
574             cm_PutConn(conns[i]);
575
576             tsp = serversp[i];
577             cm_GCConnections(tsp);
578
579             lock_ObtainMutex(&tsp->mx);
580             wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
581
582             if (results[i] >= 0 || results[i] == RXGEN_OPCODE ||
583                 results[i] == RX_CALL_BUSY)  {
584                 /* mark server as up */
585                 _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_DOWN);
586                 tsp->downTime = 0;
587
588                 /* we currently handle 32-bits of capabilities */
589                 if (results[i] != RXGEN_OPCODE && results[i] != RX_CALL_BUSY &&
590                     caps[i].Capabilities_len > 0) {
591                     tsp->capabilities = caps[i].Capabilities_val[0];
592                     xdr_free((xdrproc_t) xdr_Capabilities, &caps[i]);
593                     caps[i].Capabilities_len = 0;
594                     caps[i].Capabilities_val = 0;
595                 } else {
596                     tsp->capabilities = 0;
597                 }
598
599                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
600                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
601                           osi_LogSaveString(afsd_logp, hoststr),
602                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
603                           tsp->capabilities);
604
605                 /* Now update the volume status if necessary */
606                 if (wasDown) {
607                     cm_server_vols_t * tsrvp;
608                     cm_volume_t * volp;
609                     int i;
610
611                     for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
612                         for (i=0; i<NUM_SERVER_VOLS; i++) {
613                             if (tsrvp->ids[i] != 0) {
614                                 cm_InitReq(&req);
615
616                                 lock_ReleaseMutex(&tsp->mx);
617                                 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
618                                                          &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
619                                 lock_ObtainMutex(&tsp->mx);
620                                 if (code == 0) {
621                                     cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
622                                     cm_PutVolume(volp);
623                                 }
624                             }
625                         }
626                     }
627                     cm_RankServer(tsp);
628                 }
629             } else {
630                 cm_MarkServerDown(tsp, results[i], wasDown);
631
632                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
633                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
634                           osi_LogSaveString(afsd_logp, hoststr),
635                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
636                           tsp->capabilities);
637             }
638
639             if (tsp->waitCount == 0)
640                 _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_PINGING);
641             else
642                 osi_Wakeup((LONG_PTR)tsp);
643
644             lock_ReleaseMutex(&tsp->mx);
645
646             cm_PutServer(tsp);
647         }
648     }
649
650     if ((flags & CM_FLAG_CHECKVLDBSERVERS) ||
651         !(flags & (CM_FLAG_CHECKFILESERVERS|CM_FLAG_CHECKVLDBSERVERS)))
652     {
653         lock_ObtainRead(&cm_serverLock);
654         for (nconns=0, tsp = cm_serversAllFirstp;
655              tsp != NULL && nconns < maxconns;
656              tsp = (cm_server_t *)osi_QNext(&tsp->allq)) {
657             if (tsp->type != CM_SERVER_VLDB ||
658                 tsp->cellp == NULL ||           /* SetPref only */
659                 cellp && cellp != tsp->cellp)
660                 continue;
661
662             cm_GetServerNoLock(tsp);
663             lock_ReleaseRead(&cm_serverLock);
664
665             lock_ObtainMutex(&tsp->mx);
666             isDown = tsp->flags & CM_SERVERFLAG_DOWN;
667
668             if ((tsp->flags & CM_SERVERFLAG_PINGING) ||
669                 !((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
670                    (!isDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
671                 lock_ReleaseMutex(&tsp->mx);
672                 lock_ObtainRead(&cm_serverLock);
673                 cm_PutServerNoLock(tsp);
674                 continue;
675             }
676
677             _InterlockedOr(&tsp->flags, CM_SERVERFLAG_PINGING);
678             lock_ReleaseMutex(&tsp->mx);
679
680             serversp[nconns] = tsp;
681             if (cm_noIPAddr > 0)
682                 code = cm_ConnByServer(tsp, cm_rootUserp, FALSE, &conns[nconns]);
683             else
684                 code = RX_CALL_DEAD;
685             if (code) {
686                 if (code == RX_CALL_DEAD) {
687                     lock_ObtainMutex(&tsp->mx);
688                     cm_MarkServerDown(tsp, code, isDown);
689                     lock_ReleaseMutex(&tsp->mx);
690                 }
691                 lock_ObtainRead(&cm_serverLock);
692                 cm_PutServerNoLock(tsp);
693                 continue;
694             }
695             lock_ObtainRead(&cm_serverLock);
696             rxconns[nconns] = cm_GetRxConn(conns[nconns]);
697             conntimer[nconns] = (isDown ? 1 : 0);
698             if (isDown)
699                 rx_SetConnHardDeadTime(rxconns[nconns], 10);
700
701             nconns++;
702         }
703         lock_ReleaseRead(&cm_serverLock);
704
705         if (nconns) {
706             /* Perform the multi call */
707             start = time(NULL);
708             multi_Rx(rxconns,nconns)
709             {
710                 multi_VL_ProbeServer();
711                 results[multi_i]=multi_error;
712             } multi_End;
713         }
714
715         /* Process results of servers that support VL_ProbeServer */
716         for (i=0; i<nconns; i++) {
717             if (conntimer[i])
718                 rx_SetConnHardDeadTime(rxconns[i], HardDeadtimeout);
719             rx_PutConnection(rxconns[i]);
720             cm_PutConn(conns[i]);
721
722             tsp = serversp[i];
723             cm_GCConnections(tsp);
724
725             lock_ObtainMutex(&tsp->mx);
726             wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
727
728             if (results[i] >= 0 || results[i] == RX_CALL_BUSY)  {
729                 /* mark server as up */
730                 _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_DOWN);
731                 tsp->downTime = 0;
732                 tsp->capabilities = 0;
733
734                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
735                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
736                           osi_LogSaveString(afsd_logp, hoststr),
737                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
738                           tsp->capabilities);
739                 if (wasDown)
740                     cm_RankServer(tsp);
741             } else {
742                 cm_MarkServerDown(tsp, results[i], wasDown);
743
744                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
745                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
746                           osi_LogSaveString(afsd_logp, hoststr),
747                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
748                           tsp->capabilities);
749             }
750
751             if (tsp->waitCount == 0)
752                 _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_PINGING);
753             else
754                 osi_Wakeup((LONG_PTR)tsp);
755
756             lock_ReleaseMutex(&tsp->mx);
757
758             cm_PutServer(tsp);
759         }
760     }
761
762     free(conns);
763     free(rxconns);
764     free(conntimer);
765     free(results);
766     free(serversp);
767     free(caps);
768 }
769
770 void cm_CheckServers(afs_uint32 flags, cm_cell_t *cellp)
771 {
772     DWORD code;
773     HKEY parmKey;
774     DWORD dummyLen;
775     DWORD multi = 1;
776
777     code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
778                          0, KEY_QUERY_VALUE, &parmKey);
779     if (code == ERROR_SUCCESS) {
780         dummyLen = sizeof(multi);
781         code = RegQueryValueEx(parmKey, "MultiCheckServers", NULL, NULL,
782                                 (BYTE *) &multi, &dummyLen);
783         RegCloseKey (parmKey);
784     }
785
786     if (multi)
787         cm_CheckServersMulti(flags, cellp);
788     else
789         cm_CheckServersSingular(flags, cellp);
790 }
791
792 void cm_InitServer(void)
793 {
794     static osi_once_t once;
795
796     if (osi_Once(&once)) {
797         lock_InitializeRWLock(&cm_serverLock, "cm_serverLock", LOCK_HIERARCHY_SERVER_GLOBAL);
798         lock_InitializeRWLock(&cm_syscfgLock, "cm_syscfgLock", LOCK_HIERARCHY_SYSCFG_GLOBAL);
799         osi_EndOnce(&once);
800     }
801 }
802
803 /* Protected by cm_syscfgLock (rw) */
804 int cm_noIPAddr;         /* number of client network interfaces */
805 int cm_IPAddr[CM_MAXINTERFACE_ADDR];    /* client's IP address in host order */
806 int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
807 int cm_NetMtu[CM_MAXINTERFACE_ADDR];    /* client's MTU sizes */
808 int cm_NetFlags[CM_MAXINTERFACE_ADDR];  /* network flags */
809 int cm_LanAdapterChangeDetected = 1;
810
811 void cm_SetLanAdapterChangeDetected(void)
812 {
813     lock_ObtainWrite(&cm_syscfgLock);
814     cm_LanAdapterChangeDetected = 1;
815     lock_ReleaseWrite(&cm_syscfgLock);
816 }
817
818 void cm_GetServer(cm_server_t *serverp)
819 {
820     lock_ObtainRead(&cm_serverLock);
821     InterlockedIncrement(&serverp->refCount);
822     lock_ReleaseRead(&cm_serverLock);
823 }
824
825 void cm_GetServerNoLock(cm_server_t *serverp)
826 {
827     InterlockedIncrement(&serverp->refCount);
828 }
829
830 void cm_PutServer(cm_server_t *serverp)
831 {
832     afs_int32 refCount;
833     lock_ObtainRead(&cm_serverLock);
834     refCount = InterlockedDecrement(&serverp->refCount);
835     osi_assertx(refCount >= 0, "cm_server_t refCount underflow");
836     lock_ReleaseRead(&cm_serverLock);
837 }
838
839 void cm_PutServerNoLock(cm_server_t *serverp)
840 {
841     afs_int32 refCount = InterlockedDecrement(&serverp->refCount);
842     osi_assertx(refCount >= 0, "cm_server_t refCount underflow");
843 }
844
845 void cm_SetServerNo64Bit(cm_server_t * serverp, int no64bit)
846 {
847     lock_ObtainMutex(&serverp->mx);
848     if (no64bit)
849         _InterlockedOr(&serverp->flags, CM_SERVERFLAG_NO64BIT);
850     else
851         _InterlockedAnd(&serverp->flags, ~CM_SERVERFLAG_NO64BIT);
852     lock_ReleaseMutex(&serverp->mx);
853 }
854
855 void cm_SetServerNoInlineBulk(cm_server_t * serverp, int no)
856 {
857     lock_ObtainMutex(&serverp->mx);
858     if (no)
859         _InterlockedOr(&serverp->flags, CM_SERVERFLAG_NOINLINEBULK);
860     else
861         _InterlockedAnd(&serverp->flags, ~CM_SERVERFLAG_NOINLINEBULK);
862     lock_ReleaseMutex(&serverp->mx);
863 }
864
865 afs_int32 cm_UpdateIFInfo(void)
866 {
867     afs_int32 code;
868     /* get network related info */
869     cm_noIPAddr = CM_MAXINTERFACE_ADDR;
870     code = syscfg_GetIFInfo(&cm_noIPAddr,
871                              cm_IPAddr, cm_SubnetMask,
872                              cm_NetMtu, cm_NetFlags);
873     cm_LanAdapterChangeDetected = 0;
874     return code;
875 }
876
877 void cm_SetServerIPRank(cm_server_t * serverp)
878 {
879     unsigned long       serverAddr;     /* in host byte order */
880     unsigned long       myAddr, myNet, mySubnet;/* in host byte order */
881     unsigned long       netMask;
882     int                 i;
883     afs_int32           code;
884
885     lock_ObtainRead(&cm_syscfgLock);
886     if (cm_LanAdapterChangeDetected) {
887         lock_ConvertRToW(&cm_syscfgLock);
888         if (cm_LanAdapterChangeDetected) {
889             code = cm_UpdateIFInfo();
890         }
891         lock_ConvertWToR(&cm_syscfgLock);
892     }
893
894     serverAddr = ntohl(serverp->addr.sin_addr.s_addr);
895     serverp->ipRank  = CM_IPRANK_LOW;   /* default settings */
896
897     for ( i=0; i < cm_noIPAddr; i++)
898     {
899         /* loop through all the client's IP address and compare
900         ** each of them against the server's IP address */
901
902         myAddr = cm_IPAddr[i];
903         if ( IN_CLASSA(myAddr) )
904             netMask = IN_CLASSA_NET;
905         else if ( IN_CLASSB(myAddr) )
906             netMask = IN_CLASSB_NET;
907         else if ( IN_CLASSC(myAddr) )
908             netMask = IN_CLASSC_NET;
909         else
910             netMask = 0;
911
912         myNet    =  myAddr & netMask;
913         mySubnet =  myAddr & cm_SubnetMask[i];
914
915         if ( (serverAddr & netMask) == myNet )
916         {
917             if ( (serverAddr & cm_SubnetMask[i]) == mySubnet)
918             {
919                 if ( serverAddr == myAddr ) {
920                     serverp->ipRank = min(serverp->ipRank,
921                                            CM_IPRANK_TOP);/* same machine */
922                 } else {
923                     serverp->ipRank = min(serverp->ipRank,
924                                           CM_IPRANK_HI); /* same subnet */
925                 }
926             } else {
927                 serverp->ipRank = min(serverp->ipRank, CM_IPRANK_MED); /* same net */
928             }
929         }
930     } /* and of for loop */
931     lock_ReleaseRead(&cm_syscfgLock);
932 }
933
934 cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp, afsUUID *uuidp, afs_uint32 flags) {
935     cm_server_t *tsp;
936     char hoststr[16];
937
938     osi_assertx(socketp->sin_family == AF_INET, "unexpected socket family");
939
940     lock_ObtainWrite(&cm_serverLock);   /* get server lock */
941     tsp = cm_FindServer(socketp, type, TRUE);
942     if (tsp) {
943         /* we might have found a server created by set server prefs */
944         if (uuidp && !afs_uuid_is_nil(uuidp) &&
945             !(tsp->flags & CM_SERVERFLAG_UUID))
946         {
947             tsp->uuid = *uuidp;
948             _InterlockedOr(&tsp->flags, CM_SERVERFLAG_UUID);
949         }
950
951         if (cellp != NULL && tsp->cellp == NULL) {
952             tsp->cellp = cellp;
953             afs_inet_ntoa_r(tsp->addr.sin_addr.s_addr, hoststr);
954             osi_Log3(afsd_logp, "cm_NewServer assigning server %s to cell (%u) %s",
955                      osi_LogSaveString(afsd_logp,hoststr),
956                      cellp->cellID,
957                      osi_LogSaveString(afsd_logp,cellp->name));
958         }
959         else if (tsp->cellp != cellp) {
960             afs_inet_ntoa_r(tsp->addr.sin_addr.s_addr, hoststr);
961             osi_Log5(afsd_logp,
962                      "cm_NewServer found a server %s associated with two cells (%u) %s and (%u) %s",
963                      osi_LogSaveString(afsd_logp,hoststr),
964                      tsp->cellp->cellID,
965                      osi_LogSaveString(afsd_logp,tsp->cellp->name),
966                      cellp->cellID,
967                      osi_LogSaveString(afsd_logp,cellp->name));
968         }
969         lock_ReleaseWrite(&cm_serverLock);
970         return tsp;
971     }
972
973     tsp = malloc(sizeof(*tsp));
974     if (tsp) {
975         memset(tsp, 0, sizeof(*tsp));
976         tsp->type = type;
977         if (uuidp && !afs_uuid_is_nil(uuidp)) {
978             tsp->uuid = *uuidp;
979             _InterlockedOr(&tsp->flags, CM_SERVERFLAG_UUID);
980         }
981         tsp->refCount = 1;
982         lock_InitializeMutex(&tsp->mx, "cm_server_t mutex", LOCK_HIERARCHY_SERVER);
983         tsp->addr = *socketp;
984
985         osi_QAddH((osi_queue_t **)&cm_serversAllFirstp,
986                   (osi_queue_t **)&cm_serversAllLastp, &tsp->allq);
987
988         switch (type) {
989         case CM_SERVER_VLDB:
990             cm_numVldbServers++;
991             break;
992         case CM_SERVER_FILE:
993             cm_numFileServers++;
994             break;
995         }
996
997         if (cellp != NULL) {
998             tsp->cellp = cellp;
999             afs_inet_ntoa_r(tsp->addr.sin_addr.s_addr, hoststr);
1000             osi_Log3(afsd_logp, "cm_NewServer new server %s in cell (%u) %s",
1001                      osi_LogSaveString(afsd_logp,hoststr),
1002                      cellp->cellID,
1003                      osi_LogSaveString(afsd_logp,cellp->name));
1004         }
1005     }
1006     lock_ReleaseWrite(&cm_serverLock);  /* release server lock */
1007
1008     if (tsp) {
1009         if (!(flags & CM_FLAG_NOPROBE)) {
1010             _InterlockedOr(&tsp->flags, CM_SERVERFLAG_DOWN);    /* assume down; ping will mark up if available */
1011             lock_ObtainMutex(&tsp->mx);
1012             cm_RankServer(tsp);
1013             lock_ReleaseMutex(&tsp->mx);
1014             cm_PingServer(tsp);                                 /* Obtain Capabilities and check up/down state */
1015         } else {
1016             pthread_t phandle;
1017             pthread_attr_t tattr;
1018             int pstatus;
1019
1020             /* Probe the server in the background to determine if it is up or down */
1021             pthread_attr_init(&tattr);
1022             pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
1023
1024             lock_ObtainMutex(&tsp->mx);
1025             cm_RankServer(tsp);
1026             lock_ReleaseMutex(&tsp->mx);
1027             pstatus = pthread_create(&phandle, &tattr, cm_PingServer, tsp);
1028
1029             pthread_attr_destroy(&tattr);
1030         }
1031     }
1032     return tsp;
1033 }
1034
1035 cm_server_t *
1036 cm_FindServerByIP(afs_uint32 ipaddr, unsigned short port, int type, int locked)
1037 {
1038     cm_server_t *tsp;
1039
1040     if (!locked)
1041         lock_ObtainRead(&cm_serverLock);
1042
1043     for (tsp = cm_serversAllFirstp;
1044          tsp;
1045          tsp = (cm_server_t *)osi_QNext(&tsp->allq)) {
1046         if (tsp->type == type &&
1047             tsp->addr.sin_addr.S_un.S_addr == ipaddr &&
1048             (tsp->addr.sin_port == port || tsp->addr.sin_port == 0))
1049             break;
1050     }
1051
1052     /* bump ref count if we found the server */
1053     if (tsp)
1054         cm_GetServerNoLock(tsp);
1055
1056     if (!locked)
1057         lock_ReleaseRead(&cm_serverLock);
1058
1059     return tsp;
1060 }
1061
1062 cm_server_t *
1063 cm_FindServerByUuid(afsUUID *serverUuid, int type, int locked)
1064 {
1065     cm_server_t *tsp;
1066
1067     if (!locked)
1068         lock_ObtainRead(&cm_serverLock);
1069
1070     for (tsp = cm_serversAllFirstp;
1071          tsp;
1072          tsp = (cm_server_t *)osi_QNext(&tsp->allq)) {
1073         if (tsp->type == type && afs_uuid_equal(&tsp->uuid, serverUuid))
1074             break;
1075     }
1076
1077     /* bump ref count if we found the server */
1078     if (tsp)
1079         cm_GetServerNoLock(tsp);
1080
1081     if (!locked)
1082         lock_ReleaseRead(&cm_serverLock);
1083
1084     return tsp;
1085 }
1086
1087 /* find a server based on its properties */
1088 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type, int locked)
1089 {
1090     osi_assertx(addrp->sin_family == AF_INET, "unexpected socket value");
1091
1092     return cm_FindServerByIP(addrp->sin_addr.s_addr, addrp->sin_port, type, locked);
1093 }
1094
1095 cm_server_vols_t *cm_NewServerVols(void) {
1096     cm_server_vols_t *tsvp;
1097
1098     tsvp = malloc(sizeof(*tsvp));
1099     if (tsvp)
1100         memset(tsvp, 0, sizeof(*tsvp));
1101
1102     return tsvp;
1103 }
1104
1105 /*
1106  * cm_NewServerRef() returns with the allocated cm_serverRef_t
1107  * with a refCount of 1.
1108  */
1109 cm_serverRef_t *cm_NewServerRef(cm_server_t *serverp, afs_uint32 volID)
1110 {
1111     cm_serverRef_t *tsrp;
1112     cm_server_vols_t **tsrvpp = NULL;
1113     afs_uint32 *slotp = NULL;
1114     int found = 0;
1115
1116     cm_GetServer(serverp);
1117     tsrp = malloc(sizeof(*tsrp));
1118     tsrp->server = serverp;
1119     tsrp->status = srv_not_busy;
1120     tsrp->next = NULL;
1121     tsrp->volID = volID;
1122     tsrp->refCount = 1;
1123
1124     /* if we have a non-zero volID, we need to add it to the list
1125      * of volumes maintained by the server.  There are two phases:
1126      * (1) see if the volID is already in the list and (2) insert
1127      * it into the first empty slot if it is not.
1128      */
1129     if (volID) {
1130         lock_ObtainMutex(&serverp->mx);
1131
1132         tsrvpp = &serverp->vols;
1133         while (*tsrvpp) {
1134             int i;
1135
1136             for (i=0; i<NUM_SERVER_VOLS; i++) {
1137                 if ((*tsrvpp)->ids[i] == volID) {
1138                     found = 1;
1139                     break;
1140                 } else if (!slotp && (*tsrvpp)->ids[i] == 0) {
1141                     slotp = &(*tsrvpp)->ids[i];
1142                 }
1143             }
1144
1145             if (found)
1146                 break;
1147
1148             tsrvpp = &(*tsrvpp)->nextp;
1149         }
1150
1151         if (!found) {
1152             if (slotp) {
1153                 *slotp = volID;
1154             } else {
1155                 /* if we didn't find an empty slot in a current
1156                  * page we must need a new page */
1157                 *tsrvpp = cm_NewServerVols();
1158                 if (*tsrvpp)
1159                     (*tsrvpp)->ids[0] = volID;
1160             }
1161         }
1162
1163         lock_ReleaseMutex(&serverp->mx);
1164     }
1165
1166     return tsrp;
1167 }
1168
1169 void cm_GetServerRef(cm_serverRef_t *tsrp, int locked)
1170 {
1171     afs_int32 refCount;
1172
1173     if (!locked)
1174         lock_ObtainRead(&cm_serverLock);
1175     refCount = InterlockedIncrement(&tsrp->refCount);
1176     if (!locked)
1177         lock_ReleaseRead(&cm_serverLock);
1178 }
1179
1180 afs_int32 cm_PutServerRef(cm_serverRef_t *tsrp, int locked)
1181 {
1182     afs_int32 refCount;
1183
1184     if (!locked)
1185         lock_ObtainRead(&cm_serverLock);
1186     refCount = InterlockedDecrement(&tsrp->refCount);
1187     osi_assertx(refCount >= 0, "cm_serverRef_t refCount underflow");
1188
1189     if (!locked)
1190         lock_ReleaseRead(&cm_serverLock);
1191
1192     return refCount;
1193 }
1194
1195 afs_uint32
1196 cm_ServerListSize(cm_serverRef_t* serversp)
1197 {
1198     afs_uint32 count = 0;
1199     cm_serverRef_t *tsrp;
1200
1201     lock_ObtainRead(&cm_serverLock);
1202     for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
1203         if (tsrp->status == srv_deleted)
1204             continue;
1205         count++;
1206     }
1207     lock_ReleaseRead(&cm_serverLock);
1208     return count;
1209 }
1210
1211 LONG_PTR cm_ChecksumServerList(cm_serverRef_t *serversp)
1212 {
1213     LONG_PTR sum = 0;
1214     int first = 1;
1215     cm_serverRef_t *tsrp;
1216
1217     lock_ObtainRead(&cm_serverLock);
1218     for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
1219         if (tsrp->status == srv_deleted)
1220             continue;
1221         if (first)
1222             first = 0;
1223         else
1224             sum <<= 1;
1225         sum ^= (LONG_PTR) tsrp->server;
1226     }
1227
1228     lock_ReleaseRead(&cm_serverLock);
1229     return sum;
1230 }
1231
1232 /*
1233 ** Insert a server into the server list keeping the list sorted in
1234 ** ascending order of ipRank.
1235 **
1236 ** The refCount of the cm_serverRef_t is not altered.
1237 */
1238 void cm_InsertServerList(cm_serverRef_t** list, cm_serverRef_t* element)
1239 {
1240     cm_serverRef_t      *current;
1241     unsigned short rank;
1242
1243     lock_ObtainWrite(&cm_serverLock);
1244     /*
1245      * Since we are grabbing the serverLock exclusively remove any
1246      * deleted serverRef objects with a zero refcount before
1247      * inserting the new item.
1248      */
1249     if (*list) {
1250         cm_serverRef_t  **currentp = list;
1251         cm_serverRef_t  **nextp = NULL;
1252         cm_serverRef_t  * next = NULL;
1253         cm_server_t     * serverp = NULL;
1254
1255         for (currentp = list; *currentp; currentp = nextp)
1256         {
1257             nextp = &(*currentp)->next;
1258             /* obtain a refcnt on next in case cm_serverLock is dropped */
1259             if (*nextp)
1260                 cm_GetServerRef(*nextp, TRUE);
1261             if ((*currentp)->refCount == 0 &&
1262                 (*currentp)->status == srv_deleted) {
1263                 next = *nextp;
1264
1265                 if ((*currentp)->volID)
1266                     cm_RemoveVolumeFromServer((*currentp)->server, (*currentp)->volID);
1267                 serverp = (*currentp)->server;
1268                 free(*currentp);
1269                 nextp = &next;
1270                 /* cm_FreeServer will drop cm_serverLock if serverp->refCount == 0 */
1271                 cm_FreeServer(serverp);
1272             }
1273             /* drop the next refcnt obtained above. */
1274             if (*nextp)
1275                 cm_PutServerRef(*nextp, TRUE);
1276         }
1277     }
1278
1279     /* insertion into empty list  or at the beginning of the list */
1280     if (!(*list))
1281     {
1282         element->next = NULL;
1283         *list = element;
1284         goto done;
1285     }
1286
1287     /*
1288      * Now that deleted entries have been removed and we know that the
1289      * list was not empty, look for duplicates.  If the element we are
1290      * inserting already exists, discard it.
1291      */
1292     for ( current = *list; current; current = current->next)
1293     {
1294         cm_server_t * server1 = current->server;
1295         cm_server_t * server2 = element->server;
1296
1297         if (current->status == srv_deleted)
1298             continue;
1299
1300         if (server1->type != server2->type)
1301             continue;
1302
1303         if (server1->addr.sin_addr.s_addr != server2->addr.sin_addr.s_addr)
1304             continue;
1305
1306         if ((server1->flags & CM_SERVERFLAG_UUID) != (server2->flags & CM_SERVERFLAG_UUID))
1307             continue;
1308
1309         if ((server1->flags & CM_SERVERFLAG_UUID) &&
1310             !afs_uuid_equal(&server1->uuid, &server2->uuid))
1311             continue;
1312
1313         /* we must have a match, discard the new element */
1314         free(element);
1315         goto done;
1316     }
1317
1318     rank = element->server->activeRank;
1319
1320         /* insertion at the beginning of the list */
1321     if ((*list)->server->activeRank > rank)
1322     {
1323         element->next = *list;
1324         *list = element;
1325         goto done;
1326     }
1327
1328     /* find appropriate place to insert */
1329     for ( current = *list; current->next; current = current->next)
1330     {
1331         if ( current->next->server->activeRank > rank )
1332             break;
1333     }
1334     element->next = current->next;
1335     current->next = element;
1336
1337   done:
1338     lock_ReleaseWrite(&cm_serverLock);
1339 }
1340 /*
1341 ** Re-sort the server list with the modified rank
1342 ** returns 0 if element was changed successfully.
1343 ** returns 1 if  list remained unchanged.
1344 */
1345 long cm_ChangeRankServer(cm_serverRef_t** list, cm_server_t*    server)
1346 {
1347     cm_serverRef_t  **current;
1348     cm_serverRef_t   *element;
1349
1350     lock_ObtainWrite(&cm_serverLock);
1351     current=list;
1352     element=0;
1353
1354     /* if there is max of one element in the list, nothing to sort */
1355     if ( (!*current) || !((*current)->next)  ) {
1356         lock_ReleaseWrite(&cm_serverLock);
1357         return 1;               /* list unchanged: return success */
1358     }
1359
1360     /* if the server is on the list, delete it from list */
1361     while ( *current )
1362     {
1363         if ( (*current)->server == server)
1364         {
1365             element = (*current);
1366             *current = element->next; /* delete it */
1367             break;
1368         }
1369         current = & ( (*current)->next);
1370     }
1371     lock_ReleaseWrite(&cm_serverLock);
1372
1373     /* if this volume is not replicated on this server  */
1374     if (!element)
1375         return 1;       /* server is not on list */
1376
1377     /* re-insert deleted element into the list with modified rank*/
1378     cm_InsertServerList(list, element);
1379
1380     return 0;
1381 }
1382 /*
1383 ** If there are more than one server on the list and the first n servers on
1384 ** the list have the same rank( n>1), then randomise among the first n servers.
1385 */
1386 void cm_RandomizeServer(cm_serverRef_t** list)
1387 {
1388     int                 count, picked;
1389     cm_serverRef_t*     tsrp, *lastTsrp;
1390     unsigned short      lowestRank;
1391
1392     lock_ObtainWrite(&cm_serverLock);
1393     tsrp = *list;
1394
1395     /* an empty list or a list with only one element */
1396     if ( !tsrp || ! tsrp->next ) {
1397         lock_ReleaseWrite(&cm_serverLock);
1398         return ;
1399     }
1400
1401     /* count the number of servers with the lowest rank */
1402     lowestRank = tsrp->server->activeRank;
1403     for ( count=1, tsrp=tsrp->next; tsrp; tsrp=tsrp->next)
1404     {
1405         if ( tsrp->server->activeRank != lowestRank)
1406             break;
1407         else
1408             count++;
1409     }
1410
1411     /* if there is only one server with the lowest rank, we are done */
1412     if ( count <= 1 ) {
1413         lock_ReleaseWrite(&cm_serverLock);
1414         return ;
1415     }
1416
1417     picked = rand() % count;
1418     if ( !picked ) {
1419         lock_ReleaseWrite(&cm_serverLock);
1420         return ;
1421     }
1422
1423     tsrp = *list;
1424     while (--picked >= 0)
1425     {
1426         lastTsrp = tsrp;
1427         tsrp = tsrp->next;
1428     }
1429     lastTsrp->next = tsrp->next;  /* delete random element from list*/
1430     tsrp->next     = *list; /* insert element at the beginning of list */
1431     *list          = tsrp;
1432     lock_ReleaseWrite(&cm_serverLock);
1433 }
1434
1435 /* call cm_FreeServer while holding a write lock on cm_serverLock */
1436 void cm_FreeServer(cm_server_t* serverp)
1437 {
1438     cm_server_vols_t * tsrvp, *nextp;
1439     int delserver = 0;
1440
1441     cm_PutServerNoLock(serverp);
1442     if (serverp->refCount == 0)
1443     {
1444         /*
1445          * we need to check to ensure that all of the connections
1446          * for this server have a 0 refCount; otherwise, they will
1447          * not be garbage collected
1448          *
1449          * must drop the cm_serverLock because cm_GCConnections
1450          * obtains the cm_connLock and that comes first in the
1451          * lock hierarchy.
1452          */
1453         lock_ReleaseWrite(&cm_serverLock);
1454         cm_GCConnections(serverp);  /* connsp */
1455         lock_ObtainWrite(&cm_serverLock);
1456     }
1457
1458
1459     /*
1460      * Once we have the cm_serverLock locked check to make
1461      * sure the refCount is still zero before removing the
1462      * server entirely.
1463      */
1464     if (serverp->refCount == 0) {
1465         if (!(serverp->flags & CM_SERVERFLAG_PREF_SET)) {
1466             osi_QRemoveHT((osi_queue_t **)&cm_serversAllFirstp,
1467                           (osi_queue_t **)&cm_serversAllLastp,
1468                           &serverp->allq);
1469
1470             switch (serverp->type) {
1471             case CM_SERVER_VLDB:
1472                 cm_numVldbServers--;
1473                 break;
1474             case CM_SERVER_FILE:
1475                 cm_numFileServers--;
1476                 break;
1477             }
1478
1479             lock_FinalizeMutex(&serverp->mx);
1480
1481             /* free the volid list */
1482             for ( tsrvp = serverp->vols; tsrvp; tsrvp = nextp) {
1483                 nextp = tsrvp->nextp;
1484                 free(tsrvp);
1485             }
1486
1487             free(serverp);
1488         }
1489     }
1490 }
1491
1492 /* Called with cm_serverLock write locked */
1493 void cm_RemoveVolumeFromServer(cm_server_t * serverp, afs_uint32 volID)
1494 {
1495     cm_server_vols_t * tsrvp;
1496     int i;
1497
1498     if (volID == 0)
1499         return;
1500
1501     for (tsrvp = serverp->vols; tsrvp; tsrvp = tsrvp->nextp) {
1502         for (i=0; i<NUM_SERVER_VOLS; i++) {
1503             if (tsrvp->ids[i] == volID) {
1504                 tsrvp->ids[i] = 0;;
1505                 break;
1506             }
1507         }
1508     }
1509 }
1510
1511 int cm_IsServerListEmpty(cm_serverRef_t *serversp)
1512 {
1513     cm_serverRef_t *tsrp;
1514     int allDeleted = 1;
1515
1516     if (serversp == NULL)
1517         return CM_ERROR_EMPTY;
1518
1519     lock_ObtainRead(&cm_serverLock);
1520     for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
1521         if (tsrp->status == srv_deleted)
1522             continue;
1523         allDeleted = 0;
1524         break;
1525     }
1526     lock_ReleaseRead(&cm_serverLock);
1527
1528     return ( allDeleted ? CM_ERROR_EMPTY : 0 );
1529 }
1530
1531 void cm_FreeServerList(cm_serverRef_t** list, afs_uint32 flags)
1532 {
1533     cm_serverRef_t  **current;
1534     cm_serverRef_t  **nextp;
1535     cm_serverRef_t  * next;
1536     cm_server_t     * serverp;
1537     afs_int32         refCount;
1538
1539     lock_ObtainWrite(&cm_serverLock);
1540     current = list;
1541     nextp = 0;
1542     next = 0;
1543
1544     if (*list == NULL)
1545         goto done;
1546
1547     while (*current)
1548     {
1549         nextp = &(*current)->next;
1550         /* obtain a refcnt on next in case cm_serverLock is dropped */
1551         if (*nextp)
1552             cm_GetServerRef(*nextp, TRUE);
1553         refCount = cm_PutServerRef(*current, TRUE);
1554         if (refCount == 0) {
1555             next = *nextp;
1556
1557             if ((*current)->volID)
1558                 cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
1559             serverp = (*current)->server;
1560             free(*current);
1561             *current = next;
1562             /* cm_FreeServer will drop cm_serverLock if serverp->refCount == 0 */
1563             cm_FreeServer(serverp);
1564         } else {
1565             if (flags & CM_FREESERVERLIST_DELETE) {
1566                 (*current)->status = srv_deleted;
1567                 if ((*current)->volID)
1568                     cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
1569             }
1570             current = nextp;
1571         }
1572         /* drop the next refcnt obtained above. */
1573         if (*current)
1574             cm_PutServerRef(*current, TRUE);
1575     }
1576
1577   done:
1578
1579     lock_ReleaseWrite(&cm_serverLock);
1580 }
1581
1582 /* dump all servers to a file.
1583  * cookie is used to identify this batch for easy parsing,
1584  * and it a string provided by a caller
1585  */
1586 int cm_DumpServers(FILE *outputFile, char *cookie, int lock)
1587 {
1588     int zilch;
1589     cm_server_t *tsp;
1590     char output[1024];
1591     char uuidstr[128];
1592     char hoststr[16];
1593
1594     if (lock)
1595         lock_ObtainRead(&cm_serverLock);
1596
1597     sprintf(output,
1598             "%s - dumping servers - cm_numFileServers=%d, cm_numVldbServers=%d\r\n",
1599             cookie, cm_numFileServers, cm_numVldbServers);
1600     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1601
1602     for (tsp = cm_serversAllFirstp;
1603          tsp;
1604          tsp = (cm_server_t *)osi_QNext(&tsp->allq))
1605     {
1606         char * type;
1607         char * down;
1608
1609         switch (tsp->type) {
1610         case CM_SERVER_VLDB:
1611             type = "vldb";
1612             break;
1613         case CM_SERVER_FILE:
1614             type = "file";
1615             break;
1616         default:
1617             type = "unknown";
1618         }
1619
1620         afsUUID_to_string(&tsp->uuid, uuidstr, sizeof(uuidstr));
1621         afs_inet_ntoa_r(tsp->addr.sin_addr.s_addr, hoststr);
1622         down = ctime(&tsp->downTime);
1623         down[strlen(down)-1] = '\0';
1624
1625         sprintf(output,
1626                  "%s - tsp=0x%p cell=%s addr=%-15s port=%u uuid=%s type=%s caps=0x%x "
1627                  "flags=0x%x waitCount=%u rank=%u downTime=\"%s\" refCount=%u\r\n",
1628                  cookie, tsp, tsp->cellp ? tsp->cellp->name : "", hoststr,
1629                  ntohs(tsp->addr.sin_port), uuidstr, type,
1630                  tsp->capabilities, tsp->flags, tsp->waitCount, tsp->activeRank,
1631                  (tsp->flags & CM_SERVERFLAG_DOWN) ?  "down" : "up",
1632                  tsp->refCount);
1633         WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1634     }
1635     sprintf(output, "%s - Done dumping servers.\r\n", cookie);
1636     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1637
1638     if (lock)
1639         lock_ReleaseRead(&cm_serverLock);
1640
1641     return (0);
1642 }
1643
1644 /*
1645  * Determine if two servers are in fact the same.
1646  *
1647  * Returns 1 if they match, 0 if they do not
1648  */
1649 int cm_ServerEqual(cm_server_t *srv1, cm_server_t *srv2)
1650 {
1651     RPC_STATUS status;
1652
1653     if (srv1 == NULL || srv2 == NULL)
1654         return 0;
1655
1656     if (srv1 == srv2)
1657         return 1;
1658
1659     if (srv1->flags & CM_SERVERFLAG_UUID) {
1660         if (!(srv2->flags & CM_SERVERFLAG_UUID))
1661             return 0;
1662
1663         /* Both support UUID */
1664         if (UuidEqual((UUID *)&srv1->uuid, (UUID *)&srv2->uuid, &status))
1665             return 1;
1666     } else {
1667         if (srv2->flags & CM_SERVERFLAG_UUID)
1668             return 0;
1669
1670         /* Neither support UUID so perform an addr/port comparison */
1671         if ( srv1->addr.sin_family == srv2->addr.sin_family &&
1672              srv1->addr.sin_addr.s_addr == srv2->addr.sin_addr.s_addr &&
1673              srv1->addr.sin_port == srv2->addr.sin_port )
1674             return 1;
1675     }
1676
1677     return 0;
1678 }
1679