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 <afs/param.h>
  11 #include <afs/stds.h>
  12
  13 #ifndef DJGPP
  14 #include <windows.h>
  15 #include <winsock2.h>
  16 #include <nb30.h>
  17 #else
  18 #include <sys/socket.h>
  19 #endif /* !DJGPP */
  20 #include <stdlib.h>
  21 #include <malloc.h>
  22 #include <string.h>
  23
  24 #include <osi.h>
  25 #include <rx/rx.h>
  26 #include "afsd.h"
  27
  28 osi_rwlock_t cm_serverLock;
  29
  30 cm_server_t *cm_allServersp;
  31
  32 int cm_noIPAddr;         /* number of client network interfaces */
  33 int cm_IPAddr[CM_MAXINTERFACE_ADDR];    /* client's IP address in host order */
  34 int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
  35 int cm_NetMtu[CM_MAXINTERFACE_ADDR];    /* client's MTU sizes */
  36 int cm_NetFlags[CM_MAXINTERFACE_ADDR];  /* network flags */
  37
  38 void cm_CheckServers(long flags, cm_cell_t *cellp)
  39 {
  40     /* ping all file servers, up or down, with unauthenticated connection,
  41      * to find out whether we have all our callbacks from the server still.
  42      * Also, ping down VLDBs.
  43      */
  44     cm_server_t *tsp;
  45     long code;
  46     long secs;
  47     long usecs;
  48     int doPing;
  49     int serverType;
  50     long now;
  51     int wasDown;
  52     cm_conn_t *connp;
  53     struct rx_connection * callp;
  54
  55     lock_ObtainWrite(&cm_serverLock);
  56     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
  57         cm_GetServerNoLock(tsp);
  58         lock_ReleaseWrite(&cm_serverLock);
  59
  60         /* now process the server */
  61         lock_ObtainMutex(&tsp->mx);
  62
  63         /* what time is it? */
  64         now = osi_Time();
  65
  66         serverType = tsp->type;
  67         doPing = 0;
  68         wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
  69
  70         /* only do the ping if the cell matches the requested cell, or we're
  71          * matching all cells (cellp == NULL), and if we've requested to ping
  72          * this type of {up, down} servers.
  73          */
  74         if ((cellp == NULL || cellp == tsp->cellp) &&
  75              ((wasDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
  76                (!wasDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
  77
  78             doPing = 1;
  79         }       /* we're supposed to check this up/down server */
  80         lock_ReleaseMutex(&tsp->mx);
  81
  82         /* at this point, we've adjusted the server state, so do the ping and
  83          * adjust things.
  84          */
  85         if (doPing) {
  86             code = cm_ConnByServer(tsp, cm_rootUserp, &connp);
  87             if (code == 0) {
  88                 /* now call the appropriate ping call.  Drop the timeout if
  89                  * the server is known to be down, so that we don't waste a
  90                  * lot of time retiming out down servers.
  91                  */
  92                 if (wasDown)
  93                     rx_SetConnDeadTime(connp->callp, 10);
  94                 if (serverType == CM_SERVER_VLDB) {
  95                     code = VL_ProbeServer(connp->callp);
  96                 }
  97                 else {
  98                     /* file server */
  99                     callp = cm_GetRxConn(connp);
 100                     code = RXAFS_GetTime(callp, &secs, &usecs);
 101                     rx_PutConnection(callp);
 102                 }
 103                 if (wasDown)
 104                     rx_SetConnDeadTime(connp->callp, ConnDeadtimeout);
 105                 cm_PutConn(connp);
 106             }   /* got an unauthenticated connection to this server */
 107
 108             lock_ObtainMutex(&tsp->mx);
 109             if (code == 0) {
 110                 /* mark server as up */
 111                 tsp->flags &= ~CM_SERVERFLAG_DOWN;
 112             }
 113             else {
 114                 /* mark server as down */
 115                 tsp->flags |= CM_SERVERFLAG_DOWN;
 116             }
 117             lock_ReleaseMutex(&tsp->mx);
 118         }
 119
 120         /* also, run the GC function for connections on all of the
 121          * server's connections.
 122          */
 123         cm_GCConnections(tsp);
 124
 125         lock_ObtainWrite(&cm_serverLock);
 126         cm_PutServerNoLock(tsp);
 127     }
 128     lock_ReleaseWrite(&cm_serverLock);
 129 }
 130
 131 void cm_InitServer(void)
 132 {
 133     static osi_once_t once;
 134
 135     if (osi_Once(&once)) {
 136         lock_InitializeRWLock(&cm_serverLock, "cm_serverLock");
 137         osi_EndOnce(&once);
 138     }
 139 }
 140
 141 void cm_GetServer(cm_server_t *serverp)
 142 {
 143     lock_ObtainWrite(&cm_serverLock);
 144     serverp->refCount++;
 145     lock_ReleaseWrite(&cm_serverLock);
 146 }
 147
 148 void cm_GetServerNoLock(cm_server_t *serverp)
 149 {
 150     serverp->refCount++;
 151 }
 152
 153 void cm_PutServer(cm_server_t *serverp)
 154 {
 155     lock_ObtainWrite(&cm_serverLock);
 156     osi_assert(serverp->refCount-- > 0);
 157     lock_ReleaseWrite(&cm_serverLock);
 158 }
 159
 160 void cm_PutServerNoLock(cm_server_t *serverp)
 161 {
 162     osi_assert(serverp->refCount-- > 0);
 163 }
 164
 165 void cm_SetServerPrefs(cm_server_t * serverp)
 166 {
 167     unsigned long       serverAddr;     /* in host byte order */
 168     unsigned long       myAddr, myNet, mySubnet;/* in host byte order */
 169     unsigned long       netMask;
 170     int                 i;
 171
 172     /* implement server prefs for fileservers only */
 173     if ( serverp->type == CM_SERVER_FILE )
 174     {
 175         serverAddr = ntohl(serverp->addr.sin_addr.s_addr);
 176         serverp->ipRank  = CM_IPRANK_LOW;       /* default setings */
 177
 178         for ( i=0; i < cm_noIPAddr; i++)
 179         {
 180             /* loop through all the client's IP address and compare
 181             ** each of them against the server's IP address */
 182
 183             myAddr = cm_IPAddr[i];
 184             if ( IN_CLASSA(myAddr) )
 185                 netMask = IN_CLASSA_NET;
 186             else if ( IN_CLASSB(myAddr) )
 187                 netMask = IN_CLASSB_NET;
 188             else if ( IN_CLASSC(myAddr) )
 189                 netMask = IN_CLASSC_NET;
 190             else
 191                 netMask = 0;
 192
 193             myNet    =  myAddr & netMask;
 194             mySubnet =  myAddr & cm_SubnetMask[i];
 195
 196             if ( (serverAddr & netMask) == myNet )
 197             {
 198                 if ( (serverAddr & cm_SubnetMask[i]) == mySubnet)
 199                 {
 200                     if ( serverAddr == myAddr )
 201                         serverp->ipRank = min(serverp->ipRank,
 202                                                CM_IPRANK_TOP);/* same machine */
 203                     else serverp->ipRank = min(serverp->ipRank,
 204                                                 CM_IPRANK_HI); /* same subnet */
 205                 }
 206                 else serverp->ipRank = min(serverp->ipRank,CM_IPRANK_MED);
 207                 /* same net */
 208             }
 209             /* random between 0..15*/
 210             serverp->ipRank += min(serverp->ipRank, rand() % 0x000f);
 211         } /* and of for loop */
 212     }
 213     else
 214         serverp->ipRank = 10000 + (rand() % 0x00ff); /* VL server */
 215 }
 216
 217 cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp) {
 218     cm_server_t *tsp;
 219
 220     osi_assert(socketp->sin_family == AF_INET);
 221
 222     tsp = malloc(sizeof(*tsp));
 223     memset(tsp, 0, sizeof(*tsp));
 224     tsp->type = type;
 225     tsp->cellp = cellp;
 226     tsp->refCount = 1;
 227     lock_InitializeMutex(&tsp->mx, "cm_server_t mutex");
 228     tsp->addr = *socketp;
 229
 230     cm_SetServerPrefs(tsp);
 231
 232     lock_ObtainWrite(&cm_serverLock); /* get server lock */
 233     tsp->allNextp = cm_allServersp;
 234     cm_allServersp = tsp;
 235     lock_ReleaseWrite(&cm_serverLock); /* release server lock */
 236
 237     return tsp;
 238 }
 239
 240 /* find a server based on its properties */
 241 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type)
 242 {
 243     cm_server_t *tsp;
 244
 245     osi_assert(addrp->sin_family == AF_INET);
 246
 247     lock_ObtainWrite(&cm_serverLock);
 248     for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
 249         if (tsp->type == type &&
 250              tsp->addr.sin_addr.s_addr == addrp->sin_addr.s_addr) break;
 251     }
 252
 253     /* bump ref count if we found the server */
 254     if (tsp)
 255         cm_GetServerNoLock(tsp);
 256
 257     /* drop big table lock */
 258     lock_ReleaseWrite(&cm_serverLock);
 259
 260     /* return what we found */
 261     return tsp;
 262 }
 263
 264 cm_serverRef_t *cm_NewServerRef(cm_server_t *serverp)
 265 {
 266     cm_serverRef_t *tsrp;
 267
 268     cm_GetServer(serverp);
 269     tsrp = malloc(sizeof(*tsrp));
 270     tsrp->server = serverp;
 271     tsrp->status = not_busy;
 272     tsrp->next = NULL;
 273     tsrp->refCount = 1;
 274
 275     return tsrp;
 276 }
 277
 278 long cm_ChecksumServerList(cm_serverRef_t *serversp)
 279 {
 280     long sum = 0;
 281     int first = 1;
 282     cm_serverRef_t *tsrp;
 283
 284     lock_ObtainWrite(&cm_serverLock);
 285     for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
 286         if (first)
 287             first = 0;
 288         else
 289             sum <<= 1;
 290         sum ^= (long) tsrp->server;
 291     }
 292
 293     lock_ReleaseWrite(&cm_serverLock);
 294     return sum;
 295 }
 296
 297 /*
 298 ** Insert a server into the server list keeping the list sorted in
 299 ** asending order of ipRank.
 300 **
 301 ** The refCount of the cm_serverRef_t is increased
 302 */
 303 void cm_InsertServerList(cm_serverRef_t** list, cm_serverRef_t* element)
 304 {
 305     cm_serverRef_t      *current=*list;
 306     unsigned short ipRank = element->server->ipRank;
 307
 308     lock_ObtainWrite(&cm_serverLock);
 309     element->refCount++;                /* increase refCount */
 310
 311     /* insertion into empty list  or at the beginning of the list */
 312     if ( !current || (current->server->ipRank > ipRank) )
 313     {
 314         element->next = *list;
 315         *list = element;
 316         lock_ReleaseWrite(&cm_serverLock);
 317         return ;
 318     }
 319
 320     while ( current->next ) /* find appropriate place to insert */
 321     {
 322         if ( current->next->server->ipRank > ipRank )
 323             break;
 324         else current = current->next;
 325     }
 326     element->next = current->next;
 327     current->next = element;
 328     lock_ReleaseWrite(&cm_serverLock);
 329 }
 330 /*
 331 ** Re-sort the server list with the modified rank
 332 ** returns 0 if element was changed successfully.
 333 ** returns 1 if  list remained unchanged.
 334 */
 335 long cm_ChangeRankServer(cm_serverRef_t** list, cm_server_t*    server)
 336 {
 337     cm_serverRef_t  **current=list;
 338     cm_serverRef_t      *element=0;
 339
 340     /* if there is max of one element in the list, nothing to sort */
 341     if ( (!*current) || !((*current)->next)  )
 342         return 1;               /* list unchanged: return success */
 343
 344     lock_ObtainWrite(&cm_serverLock);
 345     /* if the server is on the list, delete it from list */
 346     while ( *current )
 347     {
 348         if ( (*current)->server == server)
 349         {
 350             element = (*current);
 351             *current = (*current)->next; /* delete it */
 352             break;
 353         }
 354         current = & ( (*current)->next);
 355     }
 356     lock_ReleaseWrite(&cm_serverLock);
 357
 358     /* if this volume is not replicated on this server  */
 359     if (!element)
 360         return 1;       /* server is not on list */
 361
 362     /* re-insert deleted element into the list with modified rank*/
 363     cm_InsertServerList(list, element);
 364
 365     /* reduce refCount which was increased by cm_InsertServerList */
 366     lock_ObtainWrite(&cm_serverLock);
 367     element->refCount--;
 368     lock_ReleaseWrite(&cm_serverLock);
 369     return 0;
 370 }
 371 /*
 372 ** If there are more than one server on the list and the first n servers on
 373 ** the list have the same rank( n>1), then randomise among the first n servers.
 374 */
 375 void cm_RandomizeServer(cm_serverRef_t** list)
 376 {
 377     int                 count, picked;
 378     cm_serverRef_t*     tsrp = *list, *lastTsrp;
 379     unsigned short      lowestRank;
 380
 381     /* an empty list or a list with only one element */
 382     if ( !tsrp || ! tsrp->next )
 383         return ;
 384
 385     lock_ObtainWrite(&cm_serverLock);
 386
 387     /* count the number of servers with the lowest rank */
 388     lowestRank = tsrp->server->ipRank;
 389     for ( count=1, tsrp=tsrp->next; tsrp; tsrp=tsrp->next)
 390     {
 391         if ( tsrp->server->ipRank != lowestRank)
 392             break;
 393         else
 394             count++;
 395     }
 396
 397     /* if there is only one server with the lowest rank, we are done */
 398     if ( count <= 1 ) {
 399         lock_ReleaseWrite(&cm_serverLock);
 400         return ;
 401     }
 402
 403     picked = rand() % count;
 404     if ( !picked ) {
 405         lock_ReleaseWrite(&cm_serverLock);
 406         return ;
 407     }
 408
 409     tsrp = *list;
 410     while (--picked >= 0)
 411     {
 412         lastTsrp = tsrp;
 413         tsrp = tsrp->next;
 414     }
 415     lastTsrp->next = tsrp->next;  /* delete random element from list*/
 416     tsrp->next     = *list; /* insert element at the beginning of list */
 417     *list          = tsrp;
 418     lock_ReleaseWrite(&cm_serverLock);
 419 }
 420
 421 /* call cm_FreeServer while holding a write lock on cm_serverLock */
 422 void cm_FreeServer(cm_server_t* serverp)
 423 {
 424     cm_PutServerNoLock(serverp);
 425     if (serverp->refCount == 0)
 426     {
 427         /* we need to check to ensure that all of the connections
 428          * for this server have a 0 refCount; otherwise, they will
 429          * not be garbage collected
 430          */
 431         cm_GCConnections(serverp);  /* connsp */
 432
 433         lock_FinalizeMutex(&serverp->mx);
 434         if ( cm_allServersp == serverp )
 435             cm_allServersp = serverp->allNextp;
 436         else {
 437             cm_server_t *tsp;
 438
 439             for(tsp = cm_allServersp; tsp->allNextp; tsp=tsp->allNextp) {
 440                 if ( tsp->allNextp == serverp ) {
 441                     tsp->allNextp = serverp->allNextp;
 442                     break;
 443                 }
 444             }
 445         }
 446     }
 447  }
 448
 449 void cm_FreeServerList(cm_serverRef_t** list)
 450 {
 451     cm_serverRef_t  **current = list;
 452     cm_serverRef_t  **nextp = 0;
 453     cm_serverRef_t  * next = 0;
 454
 455     lock_ObtainWrite(&cm_serverLock);
 456
 457     while (*current)
 458     {
 459         nextp = &(*current)->next;
 460         if (--((*current)->refCount) == 0) {
 461             next = *nextp;
 462             cm_FreeServer((*current)->server);
 463             free(*current);
 464             *current = next;
 465         } else {
 466            current = nextp;
 467         }
 468     }
 469
 470     lock_ReleaseWrite(&cm_serverLock);
 471 }
 472