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