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