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