src/afs/afs_cell.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 /*
  11  * Implements:
  12  */
  13 #include <afsconfig.h>
  14 #include "afs/param.h"
  15
  16
  17 #include "afs/stds.h"
  18 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  19 #include "afsincludes.h"        /* Afs-based standard headers */
  20 #include "afs/afs_stats.h"      /* afs statistics */
  21 #include "afs/afs_osi.h"
  22 #include "hcrypto/md5.h"
  23
  24 /* Local variables. */
  25 afs_rwlock_t afs_xcell;         /* Export for cmdebug peeking at locks */
  26
  27 /*
  28  * AFSDB implementation:
  29  *
  30  * afs_StopAFSDB: terminate the AFSDB handler, used on shutdown
  31  * afs_AFSDBHandler: entry point for user-space AFSDB request handler
  32  * afs_GetCellHostsAFSDB: query the AFSDB handler and wait for response
  33  * afs_LookupAFSDB: look up AFSDB for given cell name and create locally
  34  */
  35
  36 afs_rwlock_t afsdb_client_lock; /* Serializes client requests */
  37 afs_rwlock_t afsdb_req_lock;    /* Serializes client requests */
  38 static char afsdb_handler_running;      /* Protected by GLOCK */
  39 static char afsdb_handler_shutdown;     /* Protected by GLOCK */
  40
  41 /* from cellconfig.h */
  42 #define MAXCELLCHARS    64
  43 static struct {
  44     /* lock moved to afsdb_req_lock for cmdebug */
  45     char pending;
  46     char complete;
  47     char *cellname;
  48 } afsdb_req;
  49
  50 /*!
  51  * Terminate the AFSDB handler, used on shutdown.
  52  */
  53 void
  54 afs_StopAFSDB(void)
  55 {
  56     if (afsdb_handler_running) {
  57         afs_osi_Wakeup(&afsdb_req);
  58     } else {
  59         afsdb_handler_shutdown = 1;
  60 #if defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV) || defined(RXK_UPCALL_ENV)
  61         afs_termState = AFSOP_STOP_RXEVENT;
  62 #else
  63         afs_termState = AFSOP_STOP_COMPLETE;
  64 #endif
  65         afs_osi_Wakeup(&afs_termState);
  66     }
  67 }
  68
  69 /*!
  70  * \brief Entry point for user-space AFSDB request handler.
  71  * Reads cell data from kerlenMsg and add new cell, or alias.
  72  * \param acellName Cell name. If a cell is found, it's name will be filled in here.
  73  * \param acellNameLen Cell name length.
  74  * \param kernelMsg Buffer containing data about host count, time out, and cell hosts ids.
  75  * \return 0 for success, < 0 for error.
  76  */
  77 int
  78 afs_AFSDBHandler(char *acellName, int acellNameLen, afs_int32 * kernelMsg)
  79 {
  80     afs_int32 timeout, code;
  81     afs_int32 cellHosts[AFS_MAXCELLHOSTS];
  82
  83     if (afsdb_handler_shutdown)
  84         return -2;
  85     afsdb_handler_running = 1;
  86
  87     ObtainSharedLock(&afsdb_req_lock, 683);
  88     if (afsdb_req.pending) {
  89         int i, hostCount;
  90
  91         UpgradeSToWLock(&afsdb_req_lock, 684);
  92         hostCount = kernelMsg[0];
  93         timeout = kernelMsg[1];
  94         if (timeout)
  95             timeout += osi_Time();
  96
  97         for (i = 0; i < AFS_MAXCELLHOSTS; i++) {
  98             if (i >= hostCount)
  99                 cellHosts[i] = 0;
 100             else
 101                 cellHosts[i] = kernelMsg[2 + i];
 102         }
 103
 104         if (hostCount)
 105             code = afs_NewCell(acellName, cellHosts, CNoSUID, NULL, 0, 0,
 106                                timeout);
 107
 108         if (!hostCount || (code && code != EEXIST))
 109             /* null out the cellname if the lookup failed */
 110             afsdb_req.cellname = NULL;
 111         else
 112             /* If we found an alias, create it */
 113             if (afs_strcasecmp(afsdb_req.cellname, acellName))
 114                 afs_NewCellAlias(afsdb_req.cellname, acellName);
 115
 116         /* Request completed, wake up the relevant thread */
 117         afsdb_req.pending = 0;
 118         afsdb_req.complete = 1;
 119         afs_osi_Wakeup(&afsdb_req);
 120         ConvertWToSLock(&afsdb_req_lock);
 121     }
 122     ConvertSToRLock(&afsdb_req_lock);
 123
 124     /* Wait for a request */
 125     while (afsdb_req.pending == 0 && afs_termState != AFSOP_STOP_AFSDB) {
 126         ReleaseReadLock(&afsdb_req_lock);
 127         afs_osi_Sleep(&afsdb_req);
 128         ObtainReadLock(&afsdb_req_lock);
 129     }
 130
 131     /* Check if we're shutting down */
 132     if (afs_termState == AFSOP_STOP_AFSDB) {
 133         ReleaseReadLock(&afsdb_req_lock);
 134
 135         /* Inform anyone waiting for us that we're going away */
 136         afsdb_handler_shutdown = 1;
 137         afsdb_handler_running = 0;
 138         afs_osi_Wakeup(&afsdb_req);
 139
 140         afs_termState = AFSOP_STOP_RXEVENT;
 141         afs_osi_Wakeup(&afs_termState);
 142         return -2;
 143     }
 144
 145     /* Return the lookup request to userspace */
 146     strncpy(acellName, afsdb_req.cellname, acellNameLen);
 147     ReleaseReadLock(&afsdb_req_lock);
 148     return 0;
 149 }
 150
 151 /*!
 152  * \brief Query the AFSDB handler and wait for response.
 153  * \param  acellName
 154  * \return 0 for success. < 0 is error.
 155  */
 156 static int
 157 afs_GetCellHostsAFSDB(char *acellName)
 158 {
 159     AFS_ASSERT_GLOCK();
 160     if (!afsdb_handler_running)
 161         return ENOENT;
 162
 163     ObtainWriteLock(&afsdb_client_lock, 685);
 164     ObtainWriteLock(&afsdb_req_lock, 686);
 165
 166     afsdb_req.cellname = acellName;
 167
 168     afsdb_req.complete = 0;
 169     afsdb_req.pending = 1;
 170     afs_osi_Wakeup(&afsdb_req);
 171     ConvertWToRLock(&afsdb_req_lock);
 172
 173     while (afsdb_handler_running && !afsdb_req.complete) {
 174         ReleaseReadLock(&afsdb_req_lock);
 175         afs_osi_Sleep(&afsdb_req);
 176         ObtainReadLock(&afsdb_req_lock);
 177     };
 178
 179     ReleaseReadLock(&afsdb_req_lock);
 180     ReleaseWriteLock(&afsdb_client_lock);
 181
 182     if (afsdb_req.cellname) {
 183         return 0;
 184     } else
 185         return ENOENT;
 186 }
 187
 188
 189 /*!
 190  * Look up AFSDB for given cell name and create locally.
 191  * \param acellName Cell name.
 192  */
 193 void
 194 afs_LookupAFSDB(char *acellName)
 195 {
 196     int code;
 197     char *cellName = afs_strdup(acellName);
 198
 199     code = afs_GetCellHostsAFSDB(cellName);
 200     afs_Trace2(afs_iclSetp, CM_TRACE_AFSDB, ICL_TYPE_STRING, cellName,
 201                ICL_TYPE_INT32, code);
 202     afs_osi_FreeStr(cellName);
 203 }
 204
 205 /*
 206  * Cell name-to-ID mapping
 207  *
 208  * afs_cellname_new: create a new cell name, optional cell number
 209  * afs_cellname_lookup_id: look up a cell name
 210  * afs_cellname_lookup_name: look up a cell number
 211  * afs_cellname_ref: note that this cell name was referenced somewhere
 212  * afs_cellname_init: load the list of cells from given inode
 213  * afs_cellname_write: write in-kernel list of cells to disk
 214  */
 215
 216 struct cell_name *afs_cellname_head;    /* Export for kdump */
 217 static afs_dcache_id_t afs_cellname_inode;
 218 static int afs_cellname_inode_set;
 219 static int afs_cellname_dirty;
 220 static afs_int32 afs_cellnum_next;
 221
 222 /*!
 223  * Create a new cell name, optional cell number.
 224  * \param  name Name of cell.
 225  * \param cellnum Cellname number.
 226  * \return Initialized structure.
 227  */
 228 static struct cell_name *
 229 afs_cellname_new(char *name, afs_int32 cellnum)
 230 {
 231     struct cell_name *cn;
 232
 233     if (cellnum == 0)
 234         cellnum = afs_cellnum_next;
 235
 236     cn = afs_osi_Alloc(sizeof(*cn));
 237     osi_Assert(cn != NULL);
 238     cn->next = afs_cellname_head;
 239     cn->cellnum = cellnum;
 240     cn->cellname = afs_strdup(name);
 241     cn->used = 0;
 242     afs_cellname_head = cn;
 243
 244     if (cellnum >= afs_cellnum_next)
 245         afs_cellnum_next = cellnum + 1;
 246
 247     return cn;
 248 }
 249
 250 /*!
 251  * Look up a cell name by id.
 252  * \param cellnum
 253  * \return
 254  */
 255 static struct cell_name *
 256 afs_cellname_lookup_id(afs_int32 cellnum)
 257 {
 258     struct cell_name *cn;
 259
 260     for (cn = afs_cellname_head; cn; cn = cn->next)
 261         if (cn->cellnum == cellnum)
 262             return cn;
 263
 264     return NULL;
 265 }
 266
 267 /*!
 268  * Look up a cell name.
 269  * \param name Cell name.
 270  * \return
 271  */
 272 static struct cell_name *
 273 afs_cellname_lookup_name(char *name)
 274 {
 275     struct cell_name *cn;
 276
 277     for (cn = afs_cellname_head; cn; cn = cn->next)
 278         if (strcmp(cn->cellname, name) == 0)
 279             return cn;
 280
 281     return NULL;
 282 }
 283
 284 /*!
 285  * Note that this cell name was referenced somewhere.
 286  * \param  cn
 287  */
 288 static void
 289 afs_cellname_ref(struct cell_name *cn)
 290 {
 291     if (!cn->used) {
 292         cn->used = 1;
 293         afs_cellname_dirty = 1;
 294     }
 295 }
 296
 297 /*!
 298  * \brief Load the list of cells from given inode.
 299  * \param inode Source inode.
 300  * \param lookupcode
 301  * \return 0 for success. < 0 for error.
 302  */
 303 int
 304 afs_cellname_init(afs_dcache_id_t *inode, int lookupcode)
 305 {
 306     struct osi_file *tfile;
 307     int cc, off = 0;
 308
 309     ObtainWriteLock(&afs_xcell, 692);
 310
 311     afs_cellnum_next = 1;
 312     afs_cellname_dirty = 0;
 313
 314     if (cacheDiskType == AFS_FCACHE_TYPE_MEM) {
 315         ReleaseWriteLock(&afs_xcell);
 316         return 0;
 317     }
 318     if (lookupcode) {
 319         ReleaseWriteLock(&afs_xcell);
 320         return lookupcode;
 321     }
 322
 323     tfile = osi_UFSOpen(inode);
 324     if (!tfile) {
 325         ReleaseWriteLock(&afs_xcell);
 326         return EIO;
 327     }
 328
 329     afs_copy_inode(&afs_cellname_inode, inode);
 330     afs_cellname_inode_set = 1;
 331
 332     while (1) {
 333         afs_int32 cellnum, clen, magic;
 334         char *cellname;
 335
 336         cc = afs_osi_Read(tfile, off, &magic, sizeof(magic));
 337         if (cc != sizeof(magic))
 338             break;
 339         if (magic != AFS_CELLINFO_MAGIC)
 340             break;
 341         off += cc;
 342
 343         cc = afs_osi_Read(tfile, off, &cellnum, sizeof(cellnum));
 344         if (cc != sizeof(cellnum))
 345             break;
 346         off += cc;
 347
 348         cc = afs_osi_Read(tfile, off, &clen, sizeof(clen));
 349         if (cc != sizeof(clen))
 350             break;
 351         off += cc;
 352
 353         cellname = afs_osi_Alloc(clen + 1);
 354         if (!cellname)
 355             break;
 356
 357         cc = afs_osi_Read(tfile, off, cellname, clen);
 358         if (cc != clen) {
 359             afs_osi_Free(cellname, clen + 1);
 360             break;
 361         }
 362         off += cc;
 363         cellname[clen] = '\0';
 364
 365         if (afs_cellname_lookup_name(cellname)
 366             || afs_cellname_lookup_id(cellnum)) {
 367             afs_osi_Free(cellname, clen + 1);
 368             break;
 369         }
 370
 371         afs_cellname_new(cellname, cellnum);
 372         afs_osi_Free(cellname, clen + 1);
 373     }
 374
 375     osi_UFSClose(tfile);
 376     ReleaseWriteLock(&afs_xcell);
 377     return 0;
 378 }
 379
 380 /*!
 381  * Write in-kernel list of cells to disk.
 382  */
 383 int
 384 afs_cellname_write(void)
 385 {
 386     struct osi_file *tfile;
 387     struct cell_name *cn;
 388     int off;
 389
 390     if (!afs_cellname_dirty || !afs_cellname_inode_set)
 391         return 0;
 392     if (afs_initState != 300)
 393         return 0;
 394
 395     ObtainWriteLock(&afs_xcell, 693);
 396     afs_cellname_dirty = 0;
 397     off = 0;
 398     tfile = osi_UFSOpen(&afs_cellname_inode);
 399     if (!tfile) {
 400         ReleaseWriteLock(&afs_xcell);
 401         return EIO;
 402     }
 403
 404     for (cn = afs_cellname_head; cn; cn = cn->next) {
 405         afs_int32 magic, cellnum, clen;
 406         int cc;
 407
 408         if (!cn->used)
 409             continue;
 410
 411         magic = AFS_CELLINFO_MAGIC;
 412         cc = afs_osi_Write(tfile, off, &magic, sizeof(magic));
 413         if (cc != sizeof(magic))
 414             break;
 415         off += cc;
 416
 417         cellnum = cn->cellnum;
 418         cc = afs_osi_Write(tfile, off, &cellnum, sizeof(cellnum));
 419         if (cc != sizeof(cellnum))
 420             break;
 421         off += cc;
 422
 423         clen = strlen(cn->cellname);
 424         cc = afs_osi_Write(tfile, off, &clen, sizeof(clen));
 425         if (cc != sizeof(clen))
 426             break;
 427         off += cc;
 428
 429         cc = afs_osi_Write(tfile, off, cn->cellname, clen);
 430         if (cc != clen)
 431             break;
 432         off += clen;
 433     }
 434
 435     osi_UFSClose(tfile);
 436     ReleaseWriteLock(&afs_xcell);
 437     return 0;
 438 }
 439
 440 /*
 441  * Cell alias implementation
 442  *
 443  * afs_FindCellAlias: look up cell alias by alias name
 444  * afs_GetCellAlias: get cell alias by index (starting at 0)
 445  * afs_PutCellAlias: put back a cell alias returned by Find or Get
 446  * afs_NewCellAlias: create new cell alias entry
 447  */
 448
 449 struct cell_alias *afs_cellalias_head;  /* Export for kdump */
 450 static afs_int32 afs_cellalias_index;
 451 static int afs_CellOrAliasExists_nl(char *aname);       /* Forward declaration */
 452
 453 /*!
 454  * Look up cell alias by alias name.
 455  * \param  alias
 456  * \return Found struct or NULL.
 457  */
 458 static struct cell_alias *
 459 afs_FindCellAlias(char *alias)
 460 {
 461     struct cell_alias *tc;
 462
 463     for (tc = afs_cellalias_head; tc != NULL; tc = tc->next)
 464         if (!strcmp(alias, tc->alias))
 465             break;
 466     return tc;
 467 }
 468
 469 /*!
 470  * Get cell alias by index (starting at 0).
 471  * \param index Cell index.
 472  * \return Found struct or null.
 473  */
 474 struct cell_alias *
 475 afs_GetCellAlias(int index)
 476 {
 477     struct cell_alias *tc;
 478
 479     ObtainReadLock(&afs_xcell);
 480     for (tc = afs_cellalias_head; tc != NULL; tc = tc->next)
 481         if (tc->index == index)
 482             break;
 483     ReleaseReadLock(&afs_xcell);
 484
 485     return tc;
 486 }
 487
 488
 489  /*!
 490   * Put back a cell alias returned by Find or Get.
 491   * \param a Alias.
 492   * \return
 493   */
 494 void
 495 afs_PutCellAlias(struct cell_alias *a)
 496 {
 497     return;
 498 }
 499
 500 /*!
 501  * Create new cell alias entry and update dynroot vnode.
 502  * \param alias
 503  * \param cell
 504  * \return
 505  */
 506 afs_int32
 507 afs_NewCellAlias(char *alias, char *cell)
 508 {
 509     struct cell_alias *tc;
 510
 511     ObtainSharedLock(&afs_xcell, 681);
 512     if (afs_CellOrAliasExists_nl(alias)) {
 513         ReleaseSharedLock(&afs_xcell);
 514         return EEXIST;
 515     }
 516
 517     UpgradeSToWLock(&afs_xcell, 682);
 518     tc = afs_osi_Alloc(sizeof(struct cell_alias));
 519     osi_Assert(tc != NULL);
 520     tc->alias = afs_strdup(alias);
 521     tc->cell = afs_strdup(cell);
 522     tc->next = afs_cellalias_head;
 523     tc->index = afs_cellalias_index++;
 524     afs_cellalias_head = tc;
 525     ReleaseWriteLock(&afs_xcell);
 526
 527     afs_DynrootInvalidate();
 528     return 0;
 529 }
 530
 531 /*
 532  * Actual cell list implementation
 533  *
 534  * afs_UpdateCellLRU: bump given cell up to the front of the LRU queue
 535  * afs_RefreshCell: look up cell information in AFSDB if timeout expired
 536  *
 537  * afs_TraverseCells: execute a callback for each existing cell
 538  * afs_TraverseCells_nl: same as above except without locking afs_xcell
 539  * afs_choose_cell_by_{name,num,index}: useful traversal callbacks
 540  *
 541  * afs_FindCellByName: return a cell with a given name, if it exists
 542  * afs_FindCellByName_nl: same as above, without locking afs_xcell
 543  * afs_GetCellByName: same as FindCellByName but tries AFSDB if not found
 544  * afs_GetCell: return a cell with a given cell number
 545  * afs_GetCellStale: same as GetCell, but does not try to refresh the data
 546  * afs_GetCellByIndex: return a cell with a given index number (starting at 0)
 547  *
 548  * afs_GetPrimaryCell: return the primary cell, if any
 549  * afs_IsPrimaryCell: returns true iff the given cell is the primary cell
 550  * afs_IsPrimaryCellNum: returns afs_IsPrimaryCell(afs_GetCell(cellnum))
 551  * afs_SetPrimaryCell: set the primary cell name to the given cell name
 552  *
 553  * afs_NewCell: create or update a cell entry
 554  */
 555
 556 struct afs_q CellLRU;           /* Export for kdump */
 557 static char *afs_thiscell = NULL;
 558 afs_int32 afs_cellindex;        /* Export for kdump */
 559
 560 /*!
 561  * Bump given cell up to the front of the LRU queue.
 562  * \param c Cell to set.
 563  */
 564 static void
 565 afs_UpdateCellLRU(struct cell *c)
 566 {
 567     ObtainWriteLock(&afs_xcell, 100);
 568     QRemove(&c->lruq);
 569     QAdd(&CellLRU, &c->lruq);
 570     ReleaseWriteLock(&afs_xcell);
 571 }
 572
 573 /*!
 574  * Look up cell information in AFSDB if timeout expired
 575  * \param ac Cell to be refreshed.
 576  * \return
 577  */
 578 static void
 579 afs_RefreshCell(struct cell *ac)
 580 {
 581     if (ac->states & CNoAFSDB)
 582         return;
 583     if (!ac->cellHosts[0] || (ac->timeout && ac->timeout <= osi_Time()))
 584         afs_LookupAFSDB(ac->cellName);
 585 }
 586
 587 /*!
 588  * Execute a callback for each existing cell, without a lock on afs_xcell.
 589  * Iterate on CellLRU, and execute a callback for each cell until given arguments are met.
 590  * \see afs_TraverseCells
 591  * \param cb Traversal callback for each cell.
 592  * \param arg Callback arguments.
 593  * \return Found data or NULL.
 594  */
 595 static void *
 596 afs_TraverseCells_nl(void *(*cb) (struct cell *, void *), void *arg)
 597 {
 598     struct afs_q *cq, *tq;
 599     struct cell *tc;
 600     void *ret = NULL;
 601
 602     for (cq = CellLRU.next; cq != &CellLRU; cq = tq) {
 603         tc = QTOC(cq);
 604
 605         /* This is assuming that a NULL return is acceptable. */
 606         if (cq) {
 607             tq = QNext(cq);
 608         } else {
 609             return NULL;
 610         }
 611
 612         ret = cb(tc, arg);
 613         if (ret)
 614             break;
 615     }
 616
 617     return ret;
 618 }
 619
 620 /*!
 621  * Execute a callback for each existing cell, with a lock on afs_xcell.
 622  * \see afs_TraverseCells_nl
 623  * \param cb Traversal callback for each cell.
 624  * \param arg
 625  * \return Found data or NULL.
 626  */
 627 void *
 628 afs_TraverseCells(void *(*cb) (struct cell *, void *), void *arg)
 629 {
 630     void *ret;
 631
 632     ObtainReadLock(&afs_xcell);
 633     ret = afs_TraverseCells_nl(cb, arg);
 634     ReleaseReadLock(&afs_xcell);
 635
 636     return ret;
 637 }
 638
 639 /*!
 640  * Useful traversal callback: Match by name.
 641  * \param cell
 642  * \param arg Cell name (compared with cell->cellName).
 643  * \return Returns found cell or NULL.
 644  */
 645 static void *
 646 afs_choose_cell_by_name(struct cell *cell, void *arg)
 647 {
 648     if (!arg) {
 649         /* Safety net */
 650         return cell;
 651     } else {
 652         return strcmp(cell->cellName, (char *)arg) ? NULL : cell;
 653     }
 654 }
 655
 656 /*!
 657  * Useful traversal callback: Match by handle.
 658  * \param cell
 659  * \param arg Cell handle (compared with cell->cellHandle).
 660  * \return Returns found cell or NULL.
 661  */
 662 static void *
 663 afs_choose_cell_by_handle(struct cell *cell, void *arg)
 664 {
 665     if (!arg) {
 666         /* Safety net */
 667         return cell;
 668     } else {
 669         return memcmp(cell->cellHandle, (char *)arg, 16) ? NULL : cell;
 670     }
 671 }
 672
 673 /*!
 674  * Useful traversal callback: Match by cell number.
 675  * \param cell
 676  * \param arg Cell number (compared with cell->cellNum).
 677  * \return Returns found cell or NULL.
 678  */
 679 static void *
 680 afs_choose_cell_by_num(struct cell *cell, void *arg)
 681 {
 682     return (cell->cellNum == *((afs_int32 *) arg)) ? cell : NULL;
 683 }
 684
 685 /*!
 686  * Useful traversal callback: Match by index.
 687  * \param cell
 688  * \param arg Cell index (compared with cell->cellIndex).
 689  * \return Returns found cell or NULL.
 690  */
 691 static void *
 692 afs_choose_cell_by_index(struct cell *cell, void *arg)
 693 {
 694     return (cell->cellIndex == *((afs_int32 *) arg)) ? cell : NULL;
 695 }
 696
 697 /*!
 698  * Return a cell with a given name, if it exists. No lock version.
 699  * Does not check AFSDB.
 700  * \param acellName Cell name.
 701  * \param locktype Type of lock to be used (not used).
 702  * \return
 703  */
 704 static struct cell *
 705 afs_FindCellByName_nl(char *acellName, afs_int32 locktype)
 706 {
 707     return afs_TraverseCells_nl(&afs_choose_cell_by_name, acellName);
 708 }
 709
 710 /*!
 711  * Return a cell with a given name, if it exists.It uses locks.
 712  * Does not check AFSDB.
 713  * \param acellName Cell name.
 714  * \param locktype Type of lock to be used.
 715  * \return
 716  */
 717 static struct cell *
 718 afs_FindCellByName(char *acellName, afs_int32 locktype)
 719 {
 720     return afs_TraverseCells(&afs_choose_cell_by_name, acellName);
 721 }
 722
 723 /*!
 724  * Same as FindCellByName but tries AFSDB if not found.
 725  * \param acellName Cell name.
 726  * \param locktype Type of lock to be used.
 727  * \return
 728  */
 729 struct cell *
 730 afs_GetCellByName(char *acellName, afs_int32 locktype)
 731 {
 732     struct cell *tc;
 733
 734     tc = afs_FindCellByName(acellName, locktype);
 735     if (!tc) {
 736         afs_LookupAFSDB(acellName);
 737         tc = afs_FindCellByName(acellName, locktype);
 738     }
 739     if (tc) {
 740         afs_cellname_ref(tc->cnamep);
 741         afs_UpdateCellLRU(tc);
 742         afs_RefreshCell(tc);
 743     }
 744
 745     return tc;
 746 }
 747
 748 /*!
 749  * Return a cell with a given cell number.
 750  * \param cellnum Cell number.
 751  * \param locktype Lock to be used.
 752  * \return
 753  */
 754 struct cell *
 755 afs_GetCell(afs_int32 cellnum, afs_int32 locktype)
 756 {
 757     struct cell *tc;
 758     struct cell_name *cn;
 759
 760     tc = afs_GetCellStale(cellnum, locktype);
 761     if (tc) {
 762         afs_RefreshCell(tc);
 763     } else {
 764         ObtainReadLock(&afs_xcell);
 765         cn = afs_cellname_lookup_id(cellnum);
 766         ReleaseReadLock(&afs_xcell);
 767         if (cn)
 768             tc = afs_GetCellByName(cn->cellname, locktype);
 769     }
 770     return tc;
 771 }
 772
 773 /*!
 774  * Same as GetCell, but does not try to refresh the data.
 775  * \param cellnum Cell number.
 776  * \param locktype What lock should be used.
 777  * \return
 778  */
 779 struct cell *
 780 afs_GetCellStale(afs_int32 cellnum, afs_int32 locktype)
 781 {
 782     struct cell *tc;
 783
 784     tc = afs_TraverseCells(&afs_choose_cell_by_num, &cellnum);
 785     if (tc) {
 786         afs_cellname_ref(tc->cnamep);
 787         afs_UpdateCellLRU(tc);
 788     }
 789     return tc;
 790 }
 791
 792 /*!
 793  * Return a cell with a given index number (starting at 0). Update CellLRU as well.
 794  * \param index
 795  * \param locktype Type of lock used.
 796  * \return
 797  */
 798 struct cell *
 799 afs_GetCellByIndex(afs_int32 index, afs_int32 locktype)
 800 {
 801     struct cell *tc;
 802
 803     tc = afs_TraverseCells(&afs_choose_cell_by_index, &index);
 804     if (tc)
 805         afs_UpdateCellLRU(tc);
 806     return tc;
 807 }
 808
 809 /*!
 810  * Return a cell with a given handle..
 811  * \param index
 812  * \param locktype Type of lock used.
 813  * \return
 814  */
 815 struct cell *
 816 afs_GetCellByHandle(void *handle, afs_int32 locktype)
 817 {
 818     struct cell *tc;
 819
 820     tc = afs_TraverseCells(&afs_choose_cell_by_handle, handle);
 821     if (tc)
 822         afs_UpdateCellLRU(tc);
 823     return tc;
 824 }
 825
 826 /*!
 827  * Return primary cell, if any.
 828  * \param locktype Type of lock used.
 829  * \return
 830  */
 831 struct cell *
 832 afs_GetPrimaryCell(afs_int32 locktype)
 833 {
 834     return afs_GetCellByName(afs_thiscell, locktype);
 835 }
 836
 837 /*!
 838  * Return number of the primary cell.
 839  * \return
 840  *    Cell number, or 0 if primary cell not found
 841  */
 842 afs_int32
 843 afs_GetPrimaryCellNum(void)
 844 {
 845     struct cell *cell;
 846     afs_int32 cellNum = 0;
 847     cell = afs_GetPrimaryCell(READ_LOCK);
 848     if (cell) {
 849         cellNum = cell->cellNum;
 850         afs_PutCell(cell, READ_LOCK);
 851     }
 852     return cellNum;
 853 }
 854
 855 /*!
 856  * Returns true if the given cell is the primary cell.
 857  * \param cell
 858  * \return
 859  */
 860 int
 861 afs_IsPrimaryCell(struct cell *cell)
 862 {
 863     /* Simple safe checking */
 864     if (!cell) {
 865         return 0;
 866     } else if (!afs_thiscell) {
 867         /* This is simply a safety net to avoid seg faults especially when
 868          * using a user-space library.  afs_SetPrimaryCell() should be set
 869          * prior to this call. */
 870         afs_SetPrimaryCell(cell->cellName);
 871         return 1;
 872     } else {
 873         return strcmp(cell->cellName, afs_thiscell) ? 0 : 1;
 874     }
 875 }
 876
 877 /*!
 878  * Returns afs_IsPrimaryCell(afs_GetCell(cellnum)).
 879  * \param cellnum
 880  * \return
 881  */
 882 int
 883 afs_IsPrimaryCellNum(afs_int32 cellnum)
 884 {
 885     struct cell *tc;
 886     int primary = 0;
 887
 888     tc = afs_GetCellStale(cellnum, READ_LOCK);
 889     if (tc) {
 890         primary = afs_IsPrimaryCell(tc);
 891         afs_PutCell(tc, READ_LOCK);
 892     }
 893
 894     return primary;
 895 }
 896
 897 /*!
 898  * Set the primary cell name to the given cell name.
 899  * \param acellName Cell name.
 900  * \return 0 for success, < 0 for error.
 901  */
 902 afs_int32
 903 afs_SetPrimaryCell(char *acellName)
 904 {
 905     ObtainWriteLock(&afs_xcell, 691);
 906     if (afs_thiscell)
 907         afs_osi_FreeStr(afs_thiscell);
 908     afs_thiscell = afs_strdup(acellName);
 909     ReleaseWriteLock(&afs_xcell);
 910     return 0;
 911 }
 912
 913 /*!
 914  * Create or update a cell entry.
 915  * \param acellName Name of cell.
 916  * \param acellHosts Array of hosts that this cell has.
 917  * \param aflags Cell flags.
 918  * \param linkedcname
 919  * \param fsport File server port.
 920  * \param vlport Volume server port.
 921  * \param timeout Cell timeout value, 0 means static AFSDB entry.
 922  * \return
 923  */
 924 afs_int32
 925 afs_NewCell(char *acellName, afs_int32 * acellHosts, int aflags,
 926             char *linkedcname, u_short fsport, u_short vlport, int timeout)
 927 {
 928     struct cell *tc, *tcl = 0;
 929     afs_int32 i, newc = 0, code = 0;
 930     struct md5 m;
 931
 932     AFS_STATCNT(afs_NewCell);
 933
 934     ObtainWriteLock(&afs_xcell, 103);
 935
 936     tc = afs_FindCellByName_nl(acellName, READ_LOCK);
 937     if (tc) {
 938         aflags &= ~CNoSUID;
 939     } else {
 940         tc = afs_osi_Alloc(sizeof(struct cell));
 941         osi_Assert(tc != NULL);
 942         memset(tc, 0, sizeof(*tc));
 943         tc->cellName = afs_strdup(acellName);
 944         tc->fsport = AFS_FSPORT;
 945         tc->vlport = AFS_VLPORT;
 946         MD5_Init(&m);
 947         MD5_Update(&m, tc->cellName, strlen(tc->cellName));
 948         MD5_Final(tc->cellHandle, &m);
 949         AFS_RWLOCK_INIT(&tc->lock, "cell lock");
 950         newc = 1;
 951         aflags |= CNoSUID;
 952     }
 953     ObtainWriteLock(&tc->lock, 688);
 954
 955     /* If the cell we've found has the correct name but no timeout,
 956      * and we're called with a non-zero timeout, bail out:  never
 957      * override static configuration entries with AFSDB ones.
 958      * One exception: if the original cell entry had no servers,
 959      * it must get servers from AFSDB.
 960      */
 961     if (timeout && !tc->timeout && tc->cellHosts[0]) {
 962         code = EEXIST;          /* This code is checked for in afs_LookupAFSDB */
 963         goto bad;
 964     }
 965
 966     /* we don't want to keep pinging old vlservers which were down,
 967      * since they don't matter any more.  It's easier to do this than
 968      * to remove the server from its various hash tables. */
 969     for (i = 0; i < AFS_MAXCELLHOSTS; i++) {
 970         if (!tc->cellHosts[i])
 971             break;
 972         tc->cellHosts[i]->flags &= ~SRVR_ISDOWN;
 973         tc->cellHosts[i]->flags |= SRVR_ISGONE;
 974     }
 975
 976     if (fsport)
 977         tc->fsport = fsport;
 978     if (vlport)
 979         tc->vlport = vlport;
 980
 981     if (aflags & CLinkedCell) {
 982         if (!linkedcname) {
 983             code = EINVAL;
 984             goto bad;
 985         }
 986         tcl = afs_FindCellByName_nl(linkedcname, READ_LOCK);
 987         if (!tcl) {
 988             code = ENOENT;
 989             goto bad;
 990         }
 991         if (tcl->lcellp) {      /* XXX Overwriting if one existed before! XXX */
 992             tcl->lcellp->lcellp = (struct cell *)0;
 993             tcl->lcellp->states &= ~CLinkedCell;
 994         }
 995         tc->lcellp = tcl;
 996         tcl->lcellp = tc;
 997     }
 998     tc->states |= aflags;
 999     tc->timeout = timeout;
1000
1001     memset(tc->cellHosts, 0, sizeof(tc->cellHosts));
1002     for (i = 0; i < AFS_MAXCELLHOSTS; i++) {
1003         /* Get server for each host and link this cell in.*/
1004         struct server *ts;
1005         afs_uint32 temp = acellHosts[i];
1006         if (!temp)
1007             break;
1008         ts = afs_GetServer(&temp, 1, 0, tc->vlport, WRITE_LOCK, NULL, 0, NULL);
1009         ts->cell = tc;
1010         ts->flags &= ~SRVR_ISGONE;
1011         /* Set the server as a host of the new cell. */
1012         tc->cellHosts[i] = ts;
1013         afs_PutServer(ts, WRITE_LOCK);
1014     }
1015     afs_SortServers(tc->cellHosts, AFS_MAXCELLHOSTS);   /* randomize servers */
1016
1017     /* New cell: Build and add to LRU cell queue. */
1018     if (newc) {
1019         struct cell_name *cn;
1020
1021         cn = afs_cellname_lookup_name(acellName);
1022         if (!cn)
1023             cn = afs_cellname_new(acellName, 0);
1024
1025         tc->cnamep = cn;
1026         tc->cellNum = cn->cellnum;
1027         tc->cellIndex = afs_cellindex++;
1028         afs_stats_cmperf.numCellsVisible++;
1029         QAdd(&CellLRU, &tc->lruq);
1030     }
1031
1032     ReleaseWriteLock(&tc->lock);
1033     ReleaseWriteLock(&afs_xcell);
1034     afs_PutCell(tc, 0);
1035     if (!(aflags & CHush))
1036         afs_DynrootInvalidate();
1037     return 0;
1038
1039   bad:
1040     ReleaseWriteLock(&tc->lock);
1041
1042     if (newc) {
1043         /* If we're a new cell, nobody else can see us, so doing this
1044          * after lock release is safe */
1045         afs_osi_FreeStr(tc->cellName);
1046         afs_osi_Free(tc, sizeof(struct cell));
1047     }
1048
1049     ReleaseWriteLock(&afs_xcell);
1050     return code;
1051 }
1052
1053 /*
1054  * Miscellaneous stuff
1055  *
1056  * afs_CellInit: perform whatever initialization is necessary
1057  * shutdown_cell: called on shutdown, should deallocate memory, etc
1058  * afs_RemoveCellEntry: remove a server from a cell's server list
1059  * afs_CellOrAliasExists: check if the given name exists as a cell or alias
1060  * afs_CellOrAliasExists_nl: same as above without locking afs_xcell
1061  * afs_CellNumValid: check if a cell number is valid (also set the used flag)
1062  */
1063
1064 /*!
1065  * Perform whatever initialization is necessary.
1066  */
1067 void
1068 afs_CellInit(void)
1069 {
1070     static char CellInit_done = 0;
1071
1072     if (CellInit_done)
1073         return;
1074
1075     CellInit_done = 1;
1076
1077     AFS_RWLOCK_INIT(&afs_xcell, "afs_xcell");
1078     AFS_RWLOCK_INIT(&afsdb_client_lock, "afsdb_client_lock");
1079     AFS_RWLOCK_INIT(&afsdb_req_lock, "afsdb_req_lock");
1080     QInit(&CellLRU);
1081
1082     afs_cellindex = 0;
1083     afs_cellalias_index = 0;
1084 }
1085
1086 /*!
1087  * Called on shutdown, should deallocate memory, etc.
1088  */
1089 void
1090 shutdown_cell(void)
1091 {
1092     struct afs_q *cq, *tq;
1093     struct cell *tc;
1094
1095 #ifdef AFS_CACHE_VNODE_PATH
1096     if (cacheDiskType != AFS_FCACHE_TYPE_MEM) {
1097         afs_osi_FreeStr(afs_cellname_inode.ufs);
1098     }
1099 #endif
1100     AFS_RWLOCK_INIT(&afs_xcell, "afs_xcell");
1101
1102     for (cq = CellLRU.next; cq != &CellLRU; cq = tq) {
1103         tc = QTOC(cq);
1104         tq = QNext(cq);
1105         if (tc->cellName)
1106             afs_osi_FreeStr(tc->cellName);
1107         afs_osi_Free(tc, sizeof(struct cell));
1108     }
1109     QInit(&CellLRU);
1110
1111 {
1112     struct cell_name *cn = afs_cellname_head;
1113
1114     while (cn) {
1115         struct cell_name *next = cn->next;
1116
1117         afs_osi_FreeStr(cn->cellname);
1118         afs_osi_Free(cn, sizeof(struct cell_name));
1119         cn = next;
1120     }
1121 }
1122 }
1123
1124 /*!
1125  * Remove a server from a cell's server list.
1126  * \param srvp Server to be removed.
1127  * \return
1128  */
1129 void
1130 afs_RemoveCellEntry(struct server *srvp)
1131 {
1132     struct cell *tc;
1133     afs_int32 j, k;
1134
1135     tc = srvp->cell;
1136     if (!tc)
1137         return;
1138
1139     /* Remove the server structure from the cell list - if there */
1140     ObtainWriteLock(&tc->lock, 200);
1141     for (j = k = 0; j < AFS_MAXCELLHOSTS; j++) {
1142         if (!tc->cellHosts[j])
1143             break;
1144         if (tc->cellHosts[j] != srvp) {
1145             tc->cellHosts[k++] = tc->cellHosts[j];
1146         }
1147     }
1148     if (k == 0) {
1149         /* What do we do if we remove the last one? */
1150     }
1151     for (; k < AFS_MAXCELLHOSTS; k++) {
1152         tc->cellHosts[k] = 0;
1153     }
1154     ReleaseWriteLock(&tc->lock);
1155 }
1156
1157 /*!
1158  * Check if the given name exists as a cell or alias. Does not lock afs_xcell.
1159  * \param aname
1160  * \return
1161  */
1162 static int
1163 afs_CellOrAliasExists_nl(char *aname)
1164 {
1165     struct cell *c;
1166     struct cell_alias *ca;
1167
1168     c = afs_FindCellByName_nl(aname, READ_LOCK);
1169     if (c) {
1170         afs_PutCell(c, READ_LOCK);
1171         return 1;
1172     }
1173
1174     ca = afs_FindCellAlias(aname);
1175     if (ca) {
1176         afs_PutCellAlias(ca);
1177         return 1;
1178     }
1179
1180     return 0;
1181 }
1182
1183 /*!
1184  * Check if the given name exists as a cell or alias. Locks afs_xcell.
1185  * \param aname
1186  * \return
1187  */
1188 int
1189 afs_CellOrAliasExists(char *aname)
1190 {
1191     int ret;
1192
1193     ObtainReadLock(&afs_xcell);
1194     ret = afs_CellOrAliasExists_nl(aname);
1195     ReleaseReadLock(&afs_xcell);
1196
1197     return ret;
1198 }
1199
1200 /*!
1201  * Check if a cell number is valid (also set the used flag).
1202  * \param cellnum
1203  * \return 1 - true, 0 - false
1204  */
1205 int
1206 afs_CellNumValid(afs_int32 cellnum)
1207 {
1208     struct cell_name *cn;
1209
1210     ObtainReadLock(&afs_xcell);
1211     cn = afs_cellname_lookup_id(cellnum);
1212     ReleaseReadLock(&afs_xcell);
1213     if (cn) {
1214         cn->used = 1;
1215         return 1;
1216     } else {
1217         return 0;
1218     }
1219 }