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