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 void cm_CheckServers(long flags, cm_cell_t *cellp)
  33 {
  34     /* ping all file servers, up or down, with unauthenticated connection,
  35      * to find out whether we have all our callbacks from the server still.
  36      * Also, ping down VLDBs.
  37      */
  38     cm_server_t *tsp;
  39     long code;
  40     long secs;
  41     long usecs;
  42     int doPing;
  43     int serverType;
  44     int wasDown;
  45     cm_conn_t *connp;
  46     struct rx_connection * callp;
  47
  48     lock_ObtainWrite(&cm_serverLock);
  49     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
  50         cm_GetServerNoLock(tsp);
  51         lock_ReleaseWrite(&cm_serverLock);
  52
  53         /* now process the server */
  54         lock_ObtainMutex(&tsp->mx);
  55
  56         serverType = tsp->type;
  57         doPing = 0;
  58         wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
  59
  60         /* only do the ping if the cell matches the requested cell, or we're
  61          * matching all cells (cellp == NULL), and if we've requested to ping
  62          * this type of {up, down} servers.
  63          */
  64         if ((cellp == NULL || cellp == tsp->cellp) &&
  65              ((wasDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
  66                (!wasDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
  67
  68             doPing = 1;
  69         }       /* we're supposed to check this up/down server */
  70         lock_ReleaseMutex(&tsp->mx);
  71
  72         /* at this point, we've adjusted the server state, so do the ping and
  73          * adjust things.
  74          */
  75         if (doPing) {
  76             code = cm_ConnByServer(tsp, cm_rootUserp, &connp);
  77             if (code == 0) {
  78                 /* now call the appropriate ping call.  Drop the timeout if
  79                  * the server is known to be down, so that we don't waste a
  80                  * lot of time retiming out down servers.
  81                  */
  82                 if (wasDown)
  83                     rx_SetConnDeadTime(connp->callp, 10);
  84                 if (serverType == CM_SERVER_VLDB) {
  85                     code = VL_ProbeServer(connp->callp);
  86                 }
  87                 else {
  88                     /* file server */
  89                     callp = cm_GetRxConn(connp);
  90                     code = RXAFS_GetTime(callp, &secs, &usecs);
  91                     rx_PutConnection(callp);
  92                 }
  93                 if (wasDown)
  94                     rx_SetConnDeadTime(connp->callp, ConnDeadtimeout);
  95                 cm_PutConn(connp);
  96             }   /* got an unauthenticated connection to this server */
  97
  98             lock_ObtainMutex(&tsp->mx);
  99             if (code >= 0) {
 100                 /* mark server as up */
 101                 tsp->flags &= ~CM_SERVERFLAG_DOWN;
 102             }
 103             else {
 104                 /* mark server as down */
 105                 tsp->flags |= CM_SERVERFLAG_DOWN;
 106                 if (code != VRESTARTING)
 107                     cm_ForceNewConnections(tsp);
 108             }
 109             lock_ReleaseMutex(&tsp->mx);
 110         }
 111
 112         /* also, run the GC function for connections on all of the
 113          * server's connections.
 114          */
 115         cm_GCConnections(tsp);
 116
 117         lock_ObtainWrite(&cm_serverLock);
 118         cm_PutServerNoLock(tsp);
 119     }
 120     lock_ReleaseWrite(&cm_serverLock);
 121 }
 122
 123 void cm_InitServer(void)
 124 {
 125     static osi_once_t once;
 126
 127     if (osi_Once(&once)) {
 128         lock_InitializeRWLock(&cm_serverLock, "cm_serverLock");
 129         osi_EndOnce(&once);
 130     }
 131 }
 132
 133 void cm_GetServer(cm_server_t *serverp)
 134 {
 135     lock_ObtainWrite(&cm_serverLock);
 136     serverp->refCount++;
 137     lock_ReleaseWrite(&cm_serverLock);
 138 }
 139
 140 void cm_GetServerNoLock(cm_server_t *serverp)
 141 {
 142     serverp->refCount++;
 143 }
 144
 145 void cm_PutServer(cm_server_t *serverp)
 146 {
 147     lock_ObtainWrite(&cm_serverLock);
 148     osi_assert(serverp->refCount-- > 0);
 149     lock_ReleaseWrite(&cm_serverLock);
 150 }
 151
 152 void cm_PutServerNoLock(cm_server_t *serverp)
 153 {
 154     osi_assert(serverp->refCount-- > 0);
 155 }
 156
 157 void cm_SetServerPrefs(cm_server_t * serverp)
 158 {
 159     unsigned long       serverAddr;     /* in host byte order */
 160     unsigned long       myAddr, myNet, mySubnet;/* in host byte order */
 161     unsigned long       netMask;
 162     int                 i;
 163
 164     int cm_noIPAddr;         /* number of client network interfaces */
 165     int cm_IPAddr[CM_MAXINTERFACE_ADDR];    /* client's IP address in host order */
 166     int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
 167     int cm_NetMtu[CM_MAXINTERFACE_ADDR];    /* client's MTU sizes */
 168     int cm_NetFlags[CM_MAXINTERFACE_ADDR];  /* network flags */
 169     long code;
 170
 171     /* get network related info */
 172     cm_noIPAddr = CM_MAXINTERFACE_ADDR;
 173     code = syscfg_GetIFInfo(&cm_noIPAddr,
 174                             cm_IPAddr, cm_SubnetMask,
 175                             cm_NetMtu, cm_NetFlags);
 176
 177     serverAddr = ntohl(serverp->addr.sin_addr.s_addr);
 178     serverp->ipRank  = CM_IPRANK_LOW;   /* default setings */
 179
 180     for ( i=0; i < cm_noIPAddr; i++)
 181     {
 182         /* loop through all the client's IP address and compare
 183         ** each of them against the server's IP address */
 184
 185         myAddr = cm_IPAddr[i];
 186         if ( IN_CLASSA(myAddr) )
 187             netMask = IN_CLASSA_NET;
 188         else if ( IN_CLASSB(myAddr) )
 189             netMask = IN_CLASSB_NET;
 190         else if ( IN_CLASSC(myAddr) )
 191             netMask = IN_CLASSC_NET;
 192         else
 193             netMask = 0;
 194
 195         myNet    =  myAddr & netMask;
 196         mySubnet =  myAddr & cm_SubnetMask[i];
 197
 198         if ( (serverAddr & netMask) == myNet )
 199         {
 200             if ( (serverAddr & cm_SubnetMask[i]) == mySubnet)
 201             {
 202                 if ( serverAddr == myAddr )
 203                     serverp->ipRank = min(serverp->ipRank,
 204                                            CM_IPRANK_TOP);/* same machine */
 205                 else serverp->ipRank = min(serverp->ipRank,
 206                                             CM_IPRANK_HI); /* same subnet */
 207             }
 208             else serverp->ipRank = min(serverp->ipRank,CM_IPRANK_MED);
 209             /* same net */
 210         }
 211         /* random between 0..15*/
 212         serverp->ipRank += min(serverp->ipRank, rand() % 0x000f);
 213     } /* and of for loop */
 214 }
 215
 216 cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp) {
 217     cm_server_t *tsp;
 218
 219     osi_assert(socketp->sin_family == AF_INET);
 220
 221     tsp = malloc(sizeof(*tsp));
 222     memset(tsp, 0, sizeof(*tsp));
 223     tsp->type = type;
 224     tsp->cellp = cellp;
 225     tsp->refCount = 1;
 226     lock_InitializeMutex(&tsp->mx, "cm_server_t mutex");
 227     tsp->addr = *socketp;
 228
 229     cm_SetServerPrefs(tsp);
 230
 231     lock_ObtainWrite(&cm_serverLock); /* get server lock */
 232     tsp->allNextp = cm_allServersp;
 233     cm_allServersp = tsp;
 234     lock_ReleaseWrite(&cm_serverLock); /* release server lock */
 235
 236     return tsp;
 237 }
 238
 239 /* find a server based on its properties */
 240 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type)
 241 {
 242     cm_server_t *tsp;
 243
 244     osi_assert(addrp->sin_family == AF_INET);
 245
 246     lock_ObtainWrite(&cm_serverLock);
 247     for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
 248         if (tsp->type == type &&
 249             tsp->addr.sin_addr.s_addr == addrp->sin_addr.s_addr)
 250             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_PTR cm_ChecksumServerList(cm_serverRef_t *serversp)
 279 {
 280     LONG_PTR 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_PTR) 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         if (!(serverp->flags & CM_SERVERFLAG_PREF_SET)) {
 434             lock_FinalizeMutex(&serverp->mx);
 435             if ( cm_allServersp == serverp )
 436                 cm_allServersp = serverp->allNextp;
 437             else {
 438                 cm_server_t *tsp;
 439
 440                 for(tsp = cm_allServersp; tsp->allNextp; tsp=tsp->allNextp) {
 441                     if ( tsp->allNextp == serverp ) {
 442                         tsp->allNextp = serverp->allNextp;
 443                         break;
 444                     }
 445                 }
 446             }
 447             free(serverp);
 448         }
 449     }
 450 }
 451
 452 void cm_FreeServerList(cm_serverRef_t** list)
 453 {
 454     cm_serverRef_t  **current = list;
 455     cm_serverRef_t  **nextp = 0;
 456     cm_serverRef_t  * next = 0;
 457
 458     lock_ObtainWrite(&cm_serverLock);
 459
 460     while (*current)
 461     {
 462         nextp = &(*current)->next;
 463         if (--((*current)->refCount) == 0) {
 464             next = *nextp;
 465             cm_FreeServer((*current)->server);
 466             free(*current);
 467             *current = next;
 468         } else {
 469            current = nextp;
 470         }
 471     }
 472
 473     lock_ReleaseWrite(&cm_serverLock);
 474 }
 475