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             }
 107             lock_ReleaseMutex(&tsp->mx);
 108         }
 109
 110         /* also, run the GC function for connections on all of the
 111          * server's connections.
 112          */
 113         cm_GCConnections(tsp);
 114
 115         lock_ObtainWrite(&cm_serverLock);
 116         cm_PutServerNoLock(tsp);
 117     }
 118     lock_ReleaseWrite(&cm_serverLock);
 119 }
 120
 121 void cm_InitServer(void)
 122 {
 123     static osi_once_t once;
 124
 125     if (osi_Once(&once)) {
 126         lock_InitializeRWLock(&cm_serverLock, "cm_serverLock");
 127         osi_EndOnce(&once);
 128     }
 129 }
 130
 131 void cm_GetServer(cm_server_t *serverp)
 132 {
 133     lock_ObtainWrite(&cm_serverLock);
 134     serverp->refCount++;
 135     lock_ReleaseWrite(&cm_serverLock);
 136 }
 137
 138 void cm_GetServerNoLock(cm_server_t *serverp)
 139 {
 140     serverp->refCount++;
 141 }
 142
 143 void cm_PutServer(cm_server_t *serverp)
 144 {
 145     lock_ObtainWrite(&cm_serverLock);
 146     osi_assert(serverp->refCount-- > 0);
 147     lock_ReleaseWrite(&cm_serverLock);
 148 }
 149
 150 void cm_PutServerNoLock(cm_server_t *serverp)
 151 {
 152     osi_assert(serverp->refCount-- > 0);
 153 }
 154
 155 void cm_SetServerPrefs(cm_server_t * serverp)
 156 {
 157     unsigned long       serverAddr;     /* in host byte order */
 158     unsigned long       myAddr, myNet, mySubnet;/* in host byte order */
 159     unsigned long       netMask;
 160     int                 i;
 161
 162     int cm_noIPAddr;         /* number of client network interfaces */
 163     int cm_IPAddr[CM_MAXINTERFACE_ADDR];    /* client's IP address in host order */
 164     int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
 165     int cm_NetMtu[CM_MAXINTERFACE_ADDR];    /* client's MTU sizes */
 166     int cm_NetFlags[CM_MAXINTERFACE_ADDR];  /* network flags */
 167     long code;
 168
 169     /* get network related info */
 170     cm_noIPAddr = CM_MAXINTERFACE_ADDR;
 171     code = syscfg_GetIFInfo(&cm_noIPAddr,
 172                             cm_IPAddr, cm_SubnetMask,
 173                             cm_NetMtu, cm_NetFlags);
 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
 214 cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp) {
 215     cm_server_t *tsp;
 216
 217     osi_assert(socketp->sin_family == AF_INET);
 218
 219     tsp = malloc(sizeof(*tsp));
 220     memset(tsp, 0, sizeof(*tsp));
 221     tsp->type = type;
 222     tsp->cellp = cellp;
 223     tsp->refCount = 1;
 224     lock_InitializeMutex(&tsp->mx, "cm_server_t mutex");
 225     tsp->addr = *socketp;
 226
 227     cm_SetServerPrefs(tsp);
 228
 229     lock_ObtainWrite(&cm_serverLock); /* get server lock */
 230     tsp->allNextp = cm_allServersp;
 231     cm_allServersp = tsp;
 232     lock_ReleaseWrite(&cm_serverLock); /* release server lock */
 233
 234     return tsp;
 235 }
 236
 237 /* find a server based on its properties */
 238 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type)
 239 {
 240     cm_server_t *tsp;
 241
 242     osi_assert(addrp->sin_family == AF_INET);
 243
 244     lock_ObtainWrite(&cm_serverLock);
 245     for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
 246         if (tsp->type == type &&
 247             tsp->addr.sin_addr.s_addr == addrp->sin_addr.s_addr)
 248             break;
 249     }
 250
 251     /* bump ref count if we found the server */
 252     if (tsp)
 253         cm_GetServerNoLock(tsp);
 254
 255     /* drop big table lock */
 256     lock_ReleaseWrite(&cm_serverLock);
 257
 258     /* return what we found */
 259     return tsp;
 260 }
 261
 262 cm_serverRef_t *cm_NewServerRef(cm_server_t *serverp)
 263 {
 264     cm_serverRef_t *tsrp;
 265
 266     cm_GetServer(serverp);
 267     tsrp = malloc(sizeof(*tsrp));
 268     tsrp->server = serverp;
 269     tsrp->status = not_busy;
 270     tsrp->next = NULL;
 271     tsrp->refCount = 1;
 272
 273     return tsrp;
 274 }
 275
 276 LONG_PTR cm_ChecksumServerList(cm_serverRef_t *serversp)
 277 {
 278     LONG_PTR sum = 0;
 279     int first = 1;
 280     cm_serverRef_t *tsrp;
 281
 282     lock_ObtainWrite(&cm_serverLock);
 283     for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
 284         if (first)
 285             first = 0;
 286         else
 287             sum <<= 1;
 288         sum ^= (LONG_PTR) tsrp->server;
 289     }
 290
 291     lock_ReleaseWrite(&cm_serverLock);
 292     return sum;
 293 }
 294
 295 /*
 296 ** Insert a server into the server list keeping the list sorted in
 297 ** asending order of ipRank.
 298 **
 299 ** The refCount of the cm_serverRef_t is increased
 300 */
 301 void cm_InsertServerList(cm_serverRef_t** list, cm_serverRef_t* element)
 302 {
 303     cm_serverRef_t      *current=*list;
 304     unsigned short ipRank = element->server->ipRank;
 305
 306     lock_ObtainWrite(&cm_serverLock);
 307     element->refCount++;                /* increase refCount */
 308
 309     /* insertion into empty list  or at the beginning of the list */
 310     if ( !current || (current->server->ipRank > ipRank) )
 311     {
 312         element->next = *list;
 313         *list = element;
 314         lock_ReleaseWrite(&cm_serverLock);
 315         return ;
 316     }
 317
 318     while ( current->next ) /* find appropriate place to insert */
 319     {
 320         if ( current->next->server->ipRank > ipRank )
 321             break;
 322         else current = current->next;
 323     }
 324     element->next = current->next;
 325     current->next = element;
 326     lock_ReleaseWrite(&cm_serverLock);
 327 }
 328 /*
 329 ** Re-sort the server list with the modified rank
 330 ** returns 0 if element was changed successfully.
 331 ** returns 1 if  list remained unchanged.
 332 */
 333 long cm_ChangeRankServer(cm_serverRef_t** list, cm_server_t*    server)
 334 {
 335     cm_serverRef_t  **current=list;
 336     cm_serverRef_t      *element=0;
 337
 338     /* if there is max of one element in the list, nothing to sort */
 339     if ( (!*current) || !((*current)->next)  )
 340         return 1;               /* list unchanged: return success */
 341
 342     lock_ObtainWrite(&cm_serverLock);
 343     /* if the server is on the list, delete it from list */
 344     while ( *current )
 345     {
 346         if ( (*current)->server == server)
 347         {
 348             element = (*current);
 349             *current = (*current)->next; /* delete it */
 350             break;
 351         }
 352         current = & ( (*current)->next);
 353     }
 354     lock_ReleaseWrite(&cm_serverLock);
 355
 356     /* if this volume is not replicated on this server  */
 357     if (!element)
 358         return 1;       /* server is not on list */
 359
 360     /* re-insert deleted element into the list with modified rank*/
 361     cm_InsertServerList(list, element);
 362
 363     /* reduce refCount which was increased by cm_InsertServerList */
 364     lock_ObtainWrite(&cm_serverLock);
 365     element->refCount--;
 366     lock_ReleaseWrite(&cm_serverLock);
 367     return 0;
 368 }
 369 /*
 370 ** If there are more than one server on the list and the first n servers on
 371 ** the list have the same rank( n>1), then randomise among the first n servers.
 372 */
 373 void cm_RandomizeServer(cm_serverRef_t** list)
 374 {
 375     int                 count, picked;
 376     cm_serverRef_t*     tsrp = *list, *lastTsrp;
 377     unsigned short      lowestRank;
 378
 379     /* an empty list or a list with only one element */
 380     if ( !tsrp || ! tsrp->next )
 381         return ;
 382
 383     lock_ObtainWrite(&cm_serverLock);
 384
 385     /* count the number of servers with the lowest rank */
 386     lowestRank = tsrp->server->ipRank;
 387     for ( count=1, tsrp=tsrp->next; tsrp; tsrp=tsrp->next)
 388     {
 389         if ( tsrp->server->ipRank != lowestRank)
 390             break;
 391         else
 392             count++;
 393     }
 394
 395     /* if there is only one server with the lowest rank, we are done */
 396     if ( count <= 1 ) {
 397         lock_ReleaseWrite(&cm_serverLock);
 398         return ;
 399     }
 400
 401     picked = rand() % count;
 402     if ( !picked ) {
 403         lock_ReleaseWrite(&cm_serverLock);
 404         return ;
 405     }
 406
 407     tsrp = *list;
 408     while (--picked >= 0)
 409     {
 410         lastTsrp = tsrp;
 411         tsrp = tsrp->next;
 412     }
 413     lastTsrp->next = tsrp->next;  /* delete random element from list*/
 414     tsrp->next     = *list; /* insert element at the beginning of list */
 415     *list          = tsrp;
 416     lock_ReleaseWrite(&cm_serverLock);
 417 }
 418
 419 /* call cm_FreeServer while holding a write lock on cm_serverLock */
 420 void cm_FreeServer(cm_server_t* serverp)
 421 {
 422     cm_PutServerNoLock(serverp);
 423     if (serverp->refCount == 0)
 424     {
 425         /* we need to check to ensure that all of the connections
 426          * for this server have a 0 refCount; otherwise, they will
 427          * not be garbage collected
 428          */
 429         cm_GCConnections(serverp);  /* connsp */
 430
 431         lock_FinalizeMutex(&serverp->mx);
 432         if ( cm_allServersp == serverp )
 433             cm_allServersp = serverp->allNextp;
 434         else {
 435             cm_server_t *tsp;
 436
 437             for(tsp = cm_allServersp; tsp->allNextp; tsp=tsp->allNextp) {
 438                 if ( tsp->allNextp == serverp ) {
 439                     tsp->allNextp = serverp->allNextp;
 440                     break;
 441                 }
 442             }
 443         }
 444     }
 445  }
 446
 447 void cm_FreeServerList(cm_serverRef_t** list)
 448 {
 449     cm_serverRef_t  **current = list;
 450     cm_serverRef_t  **nextp = 0;
 451     cm_serverRef_t  * next = 0;
 452
 453     lock_ObtainWrite(&cm_serverLock);
 454
 455     while (*current)
 456     {
 457         nextp = &(*current)->next;
 458         if (--((*current)->refCount) == 0) {
 459             next = *nextp;
 460             cm_FreeServer((*current)->server);
 461             free(*current);
 462             *current = next;
 463         } else {
 464            current = nextp;
 465         }
 466     }
 467
 468     lock_ReleaseWrite(&cm_serverLock);
 469 }
 470