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