dir: Prototype and function name cleanup
[openafs.git] / src / afs / afs_dynroot.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  * Dynamic /afs volume support.
12  *
13  * Implements:
14  * afs_IsDynrootFid
15  * afs_IsDynrootMountFid
16  * afs_IsDynrootAnyFid
17  * afs_GetDynrootFid
18  * afs_GetDynrootMountFid
19  * afs_IsDynroot
20  * afs_IsDynrootMount
21  * afs_IsDynrootAny
22  * afs_DynrootInvalidate
23  * afs_GetDynroot
24  * afs_PutDynroot
25  * afs_DynrootNewVnode
26  * afs_SetDynrootEnable
27  * afs_GetDynrootEnable
28  * afs_DynrootVOPRemove
29  * afs_DynrootVOPSymlink
30  *
31  */
32
33 #include <afsconfig.h>
34 #include "afs/param.h"
35
36 #include "afs/stds.h"
37 #include "afs/sysincludes.h"    /* Standard vendor system headers */
38 #include "afsincludes.h"
39 #include "afs/afs_osi.h"
40 #include "afsint.h"
41 #include "afs/lock.h"
42
43 #include "afs/prs_fs.h"
44 #include "afs/dir.h"
45 #include "afs/afs_dynroot.h"
46
47 #define AFS_DYNROOT_CELLNAME    "dynroot"
48 #define AFS_DYNROOT_VOLUME      1
49 #define AFS_DYNROOT_VNODE       1
50 #define AFS_DYNROOT_MOUNT_VNODE 3
51 #define AFS_DYNROOT_UNIQUE      1
52
53 static int afs_dynrootInit = 0;
54 static int afs_dynrootEnable = 0;
55 static int afs_dynrootCell = 0;
56
57 static afs_rwlock_t afs_dynrootDirLock;
58 /* Start of variables protected by afs_dynrootDirLock */
59 static char *afs_dynrootDir = NULL;
60 static int afs_dynrootDirLen;
61 static char *afs_dynrootMountDir = NULL;
62 static int afs_dynrootMountDirLen;
63 static int afs_dynrootDirLinkcnt;
64 static int afs_dynrootDirVersion;
65 static int afs_dynrootVersion = 1;
66 static int afs_dynrootVersionHigh = 1;
67 /* End of variables protected by afs_dynrootDirLock */
68
69 /* A dynamically-created symlink in a dynroot /afs */
70 struct afs_dynSymlink {
71     struct afs_dynSymlink *next;
72     int index;
73     char *name;
74     char *target;
75 };
76
77 static afs_rwlock_t afs_dynSymlinkLock;
78 /* Start of variables protected by afs_dynSymlinkLock */
79 static struct afs_dynSymlink *afs_dynSymlinkBase = NULL;
80 static int afs_dynSymlinkIndex = 0;
81 /* End of variables protected by afs_dynSymlinkLock */
82
83 /*
84  * Set up a cell for dynroot if it's not there yet.
85  */
86 static int
87 afs_dynrootCellInit(void)
88 {
89     if (!afs_dynrootCell) {
90         afs_int32 cellHosts[AFS_MAXCELLHOSTS];
91         struct cell *tc;
92         int code;
93
94         memset(cellHosts, 0, sizeof(cellHosts));
95         code =
96             afs_NewCell(AFS_DYNROOT_CELLNAME, cellHosts, CNoSUID | CNoAFSDB,
97                         NULL, 0, 0, 0);
98         if (code)
99             return code;
100         tc = afs_GetCellByName(AFS_DYNROOT_CELLNAME, READ_LOCK);
101         if (!tc)
102             return ENODEV;
103         afs_dynrootCell = tc->cellNum;
104         afs_PutCell(tc, READ_LOCK);
105     }
106
107     return 0;
108 }
109
110 /*
111  * Returns non-zero iff fid corresponds to the top of the dynroot volume.
112  */
113 static int
114 _afs_IsDynrootFid(struct VenusFid *fid)
115 {
116     return (fid->Cell == afs_dynrootCell
117             && fid->Fid.Volume == AFS_DYNROOT_VOLUME
118             && fid->Fid.Vnode == AFS_DYNROOT_VNODE
119             && fid->Fid.Unique == AFS_DYNROOT_UNIQUE);
120 }
121
122 int
123 afs_IsDynrootFid(struct VenusFid *fid)
124 {
125     return (afs_dynrootEnable && _afs_IsDynrootFid(fid));
126 }
127
128 int
129 afs_IsDynrootMountFid(struct VenusFid *fid)
130 {
131     return (fid->Cell == afs_dynrootCell
132             && fid->Fid.Volume == AFS_DYNROOT_VOLUME
133             && fid->Fid.Vnode == AFS_DYNROOT_MOUNT_VNODE
134             && fid->Fid.Unique == AFS_DYNROOT_UNIQUE);
135 }
136
137 int
138 afs_IsDynrootAnyFid(struct VenusFid *fid)
139 {
140     return (fid->Cell == afs_dynrootCell
141             && fid->Fid.Volume == AFS_DYNROOT_VOLUME);
142 }
143
144 /*
145  * Obtain the magic dynroot volume Fid.
146  */
147 void
148 afs_GetDynrootFid(struct VenusFid *fid)
149 {
150     fid->Cell = afs_dynrootCell;
151     fid->Fid.Volume = AFS_DYNROOT_VOLUME;
152     fid->Fid.Vnode = AFS_DYNROOT_VNODE;
153     fid->Fid.Unique = AFS_DYNROOT_UNIQUE;
154 }
155
156 void
157 afs_GetDynrootMountFid(struct VenusFid *fid)
158 {
159     fid->Cell = afs_dynrootCell;
160     fid->Fid.Volume = AFS_DYNROOT_VOLUME;
161     fid->Fid.Vnode = AFS_DYNROOT_MOUNT_VNODE;
162     fid->Fid.Unique = AFS_DYNROOT_UNIQUE;
163 }
164
165 /*
166  * Returns non-zero iff avc is a pointer to the dynroot /afs vnode.
167  */
168 int
169 afs_IsDynroot(struct vcache *avc)
170 {
171     return afs_IsDynrootFid(&avc->f.fid);
172 }
173
174 int
175 afs_IsDynrootMount(struct vcache *avc)
176 {
177     return afs_IsDynrootMountFid(&avc->f.fid);
178 }
179
180 int
181 afs_IsDynrootAny(struct vcache *avc)
182 {
183     return afs_IsDynrootAnyFid(&avc->f.fid);
184 }
185
186 /*
187  * Given the current page and chunk pointers in a directory, adjust them
188  * appropriately so that the given file name can be appended.  Used for
189  * computing the size of a directory.
190  */
191 static void
192 afs_dynroot_computeDirEnt(char *name, int *curPageP, int *curChunkP)
193 {
194     int esize;
195
196     esize = afs_dir_NameBlobs(name);
197     if (*curChunkP + esize > EPP) {
198         *curPageP += 1;
199         *curChunkP = 1;
200     }
201     *curChunkP += esize;
202 }
203
204 /*
205  * Add directory entry by given name to a directory.  Assumes the
206  * caller has allocated the directory to be large enough to hold
207  * the necessary entry.
208  */
209 static void
210 afs_dynroot_addDirEnt(struct DirHeader *dirHeader, int *curPageP,
211                       int *curChunkP, char *name, int vnode)
212 {
213     char *dirBase = (char *)dirHeader;
214     struct PageHeader *pageHeader;
215     struct DirEntry *dirEntry;
216     int sizeOfEntry, i, t1, t2;
217     int curPage = *curPageP;
218     int curChunk = *curChunkP;
219     int didNewPage = 0;
220
221     /*
222      * Check if we need to flip pages..  If so, init the new page.
223      */
224     sizeOfEntry = afs_dir_NameBlobs(name);
225     if (curChunk + sizeOfEntry > EPP) {
226         curPage++;
227         curChunk = 1;
228         didNewPage = 1;
229     }
230
231     pageHeader = (struct PageHeader *)(dirBase + curPage * AFS_PAGESIZE);
232     if (didNewPage) {
233         pageHeader->pgcount = 0;
234         pageHeader->tag = htons(1234);
235         pageHeader->freecount = 0;
236         pageHeader->freebitmap[0] = 0x01;
237         for (i = 1; i < EPP / 8; i++)
238             pageHeader->freebitmap[i] = 0;
239
240         dirHeader->alloMap[curPage] = EPP - 1;
241     }
242
243     dirEntry = (struct DirEntry *)(pageHeader + curChunk);
244     dirEntry->flag = 1;
245     dirEntry->length = 0;
246     dirEntry->next = 0;
247     dirEntry->fid.vnode = htonl(vnode);
248     dirEntry->fid.vunique = htonl(1);
249     strcpy(dirEntry->name, name);
250
251     for (i = curChunk; i < curChunk + sizeOfEntry; i++) {
252         t1 = i / 8;
253         t2 = i % 8;
254         pageHeader->freebitmap[t1] |= (1 << t2);
255     }
256
257     /*
258      * Add the new entry to the correct hash chain.
259      */
260     i = afs_dir_DirHash(name);
261     dirEntry->next = dirHeader->hashTable[i];
262     dirHeader->hashTable[i] = htons(curPage * EPP + curChunk);
263
264     curChunk += sizeOfEntry;
265     dirHeader->alloMap[curPage] -= sizeOfEntry;
266
267     *curPageP = curPage;
268     *curChunkP = curChunk;
269 }
270
271 /*
272  * Invalidate the /afs vnode for dynroot; called when the underlying
273  * directory has changed and needs to be re-read.
274  */
275 void
276 afs_DynrootInvalidate(void)
277 {
278     afs_int32 retry;
279     struct vcache *tvc;
280     struct VenusFid tfid;
281
282     if (!afs_dynrootEnable)
283         return;
284
285     ObtainWriteLock(&afs_dynrootDirLock, 687);
286     afs_dynrootVersion++;
287     afs_dynrootVersionHigh = osi_Time();
288     ReleaseWriteLock(&afs_dynrootDirLock);
289
290     afs_GetDynrootFid(&tfid);
291     do {
292         retry = 0;
293         ObtainReadLock(&afs_xvcache);
294         tvc = afs_FindVCache(&tfid, &retry, 0);
295         ReleaseReadLock(&afs_xvcache);
296     } while (retry);
297     if (tvc) {
298         tvc->f.states &= ~(CStatd | CUnique);
299         osi_dnlc_purgedp(tvc);
300         afs_PutVCache(tvc);
301     }
302 }
303
304 /*
305  * Regenerates the dynroot contents from the current list of
306  * cells.  Useful when the list of cells has changed due to
307  * an AFSDB lookup, for instance.
308  */
309 static void
310 afs_RebuildDynroot(void)
311 {
312     int cellidx, maxcellidx, i;
313     int aliasidx, maxaliasidx;
314     struct cell *c;
315     struct cell_alias *ca;
316     int curChunk, curPage;
317     int dirSize, dotLen;
318     char *newDir, *dotCell;
319     struct DirHeader *dirHeader;
320     int linkCount = 0;
321     struct afs_dynSymlink *ts;
322     int newVersion;
323
324     ObtainReadLock(&afs_dynrootDirLock);
325     newVersion = afs_dynrootVersion;
326     ReleaseReadLock(&afs_dynrootDirLock);
327
328     /*
329      * Compute the amount of space we need for the fake dir
330      */
331     curChunk = 13;
332     curPage = 0;
333
334     /* Reserve space for "." and ".." */
335     curChunk += 2;
336
337     /* Reserve space for the dynamic-mount directory */
338     afs_dynroot_computeDirEnt(AFS_DYNROOT_MOUNTNAME, &curPage, &curChunk);
339
340     for (cellidx = 0;; cellidx++) {
341         c = afs_GetCellByIndex(cellidx, READ_LOCK);
342         if (!c)
343             break;
344         if ((c->cellNum == afs_dynrootCell) || (c->states & CHush)) {
345             afs_PutCell(c, READ_LOCK);
346             continue;
347         }
348         dotLen = strlen(c->cellName) + 2;
349         dotCell = afs_osi_Alloc(dotLen);
350         osi_Assert(dotCell != NULL);
351         strcpy(dotCell, ".");
352         afs_strcat(dotCell, c->cellName);
353
354         afs_dynroot_computeDirEnt(c->cellName, &curPage, &curChunk);
355         afs_dynroot_computeDirEnt(dotCell, &curPage, &curChunk);
356
357         afs_osi_Free(dotCell, dotLen);
358         afs_PutCell(c, READ_LOCK);
359     }
360     maxcellidx = cellidx;
361
362     for (aliasidx = 0;; aliasidx++) {
363         ca = afs_GetCellAlias(aliasidx);
364         if (!ca)
365             break;
366
367         dotLen = strlen(ca->alias) + 2;
368         dotCell = afs_osi_Alloc(dotLen);
369         osi_Assert(dotCell != NULL);
370         strcpy(dotCell, ".");
371         afs_strcat(dotCell, ca->alias);
372
373         afs_dynroot_computeDirEnt(ca->alias, &curPage, &curChunk);
374         afs_dynroot_computeDirEnt(dotCell, &curPage, &curChunk);
375
376         afs_osi_Free(dotCell, dotLen);
377         afs_PutCellAlias(ca);
378     }
379     maxaliasidx = aliasidx;
380
381     ObtainReadLock(&afs_dynSymlinkLock);
382     ts = afs_dynSymlinkBase;
383     while (ts) {
384         afs_dynroot_computeDirEnt(ts->name, &curPage, &curChunk);
385         ts = ts->next;
386     }
387
388     dirSize = (curPage + 1) * AFS_PAGESIZE;
389     newDir = afs_osi_Alloc(dirSize);
390     osi_Assert(newDir != NULL);
391
392     /*
393      * Now actually construct the directory.
394      */
395     curChunk = 13;
396     curPage = 0;
397     dirHeader = (struct DirHeader *)newDir;
398
399     dirHeader->header.pgcount = 0;
400     dirHeader->header.tag = htons(1234);
401     dirHeader->header.freecount = 0;
402
403     dirHeader->header.freebitmap[0] = 0xff;
404     dirHeader->header.freebitmap[1] = 0x1f;
405     for (i = 2; i < EPP / 8; i++)
406         dirHeader->header.freebitmap[i] = 0;
407     dirHeader->alloMap[0] = EPP - DHE - 1;
408     for (i = 1; i < MAXPAGES; i++)
409         dirHeader->alloMap[i] = EPP;
410     for (i = 0; i < NHASHENT; i++)
411         dirHeader->hashTable[i] = 0;
412
413     /* Install ".", "..", and the dynamic mount directory */
414     afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, ".", 1);
415     afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, "..", 1);
416     afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk,
417                           AFS_DYNROOT_MOUNTNAME, AFS_DYNROOT_MOUNT_VNODE);
418     linkCount += 3;
419
420     for (cellidx = 0; cellidx < maxcellidx; cellidx++) {
421         c = afs_GetCellByIndex(cellidx, READ_LOCK);
422         if (!c)
423             continue;
424         if ((c->cellNum == afs_dynrootCell) || (c->states & CHush)) {
425             afs_PutCell(c, READ_LOCK);
426             continue;
427         }
428
429         dotLen = strlen(c->cellName) + 2;
430         dotCell = afs_osi_Alloc(dotLen);
431         osi_Assert(dotCell != NULL);
432         strcpy(dotCell, ".");
433         afs_strcat(dotCell, c->cellName);
434         afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, c->cellName,
435                               VNUM_FROM_CIDX_RW(cellidx, 0));
436         afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, dotCell,
437                               VNUM_FROM_CIDX_RW(cellidx, 1));
438         afs_osi_Free(dotCell, dotLen);
439
440         linkCount += 2;
441         afs_PutCell(c, READ_LOCK);
442     }
443
444     for (aliasidx = 0; aliasidx < maxaliasidx; aliasidx++) {
445         ca = afs_GetCellAlias(aliasidx);
446         if (!ca)
447             continue;
448
449         dotLen = strlen(ca->alias) + 2;
450         dotCell = afs_osi_Alloc(dotLen);
451         osi_Assert(dotCell != NULL);
452         strcpy(dotCell, ".");
453         afs_strcat(dotCell, ca->alias);
454         afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, ca->alias,
455                               VNUM_FROM_CAIDX_RW(aliasidx, 0));
456         afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, dotCell,
457                               VNUM_FROM_CAIDX_RW(aliasidx, 1));
458         afs_osi_Free(dotCell, dotLen);
459         afs_PutCellAlias(ca);
460     }
461
462     ts = afs_dynSymlinkBase;
463     while (ts) {
464         int vnum = VNUM_FROM_TYPEID(VN_TYPE_SYMLINK, ts->index);
465         afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, ts->name, vnum);
466         ts = ts->next;
467     }
468
469     ReleaseReadLock(&afs_dynSymlinkLock);
470
471     ObtainWriteLock(&afs_dynrootDirLock, 549);
472     if (afs_dynrootDir)
473         afs_osi_Free(afs_dynrootDir, afs_dynrootDirLen);
474     afs_dynrootDir = newDir;
475     afs_dynrootDirLen = dirSize;
476     afs_dynrootDirLinkcnt = linkCount;
477     afs_dynrootDirVersion = newVersion;
478     ReleaseWriteLock(&afs_dynrootDirLock);
479 }
480
481 static void
482 afs_RebuildDynrootMount(void)
483 {
484     int i;
485     int curChunk, curPage;
486     char *newDir;
487     struct DirHeader *dirHeader;
488
489     newDir = afs_osi_Alloc(AFS_PAGESIZE);
490     osi_Assert(newDir != NULL);
491
492     /*
493      * Now actually construct the directory.
494      */
495     curChunk = 13;
496     curPage = 0;
497     dirHeader = (struct DirHeader *)newDir;
498
499     dirHeader->header.pgcount = 0;
500     dirHeader->header.tag = htons(1234);
501     dirHeader->header.freecount = 0;
502
503     dirHeader->header.freebitmap[0] = 0xff;
504     dirHeader->header.freebitmap[1] = 0x1f;
505     for (i = 2; i < EPP / 8; i++)
506         dirHeader->header.freebitmap[i] = 0;
507     dirHeader->alloMap[0] = EPP - DHE - 1;
508     for (i = 1; i < MAXPAGES; i++)
509         dirHeader->alloMap[i] = EPP;
510     for (i = 0; i < NHASHENT; i++)
511         dirHeader->hashTable[i] = 0;
512
513     /* Install "." and ".." */
514     afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, ".", 1);
515     afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, "..", 1);
516
517     ObtainWriteLock(&afs_dynrootDirLock, 549);
518     if (afs_dynrootMountDir)
519         afs_osi_Free(afs_dynrootMountDir, afs_dynrootMountDirLen);
520     afs_dynrootMountDir = newDir;
521     afs_dynrootMountDirLen = AFS_PAGESIZE;
522     ReleaseWriteLock(&afs_dynrootDirLock);
523 }
524
525 /*
526  * Returns a pointer to the base of the dynroot directory in memory,
527  * length thereof, and a FetchStatus.
528  */
529 void
530 afs_GetDynroot(char **dynrootDir, int *dynrootLen,
531                struct AFSFetchStatus *status)
532 {
533     ObtainReadLock(&afs_dynrootDirLock);
534     if (!afs_dynrootDir || afs_dynrootDirVersion != afs_dynrootVersion) {
535         ReleaseReadLock(&afs_dynrootDirLock);
536         afs_RebuildDynroot();
537         ObtainReadLock(&afs_dynrootDirLock);
538     }
539
540     if (dynrootDir)
541         *dynrootDir = afs_dynrootDir;
542     if (dynrootLen)
543         *dynrootLen = afs_dynrootDirLen;
544
545     if (status) {
546         memset(status, 0, sizeof(struct AFSFetchStatus));
547         status->FileType = Directory;
548         status->LinkCount = afs_dynrootDirLinkcnt;
549         status->Length = afs_dynrootDirLen;
550         status->DataVersion = afs_dynrootVersion;
551         status->CallerAccess = PRSFS_LOOKUP | PRSFS_READ;
552         status->AnonymousAccess = PRSFS_LOOKUP | PRSFS_READ;
553         status->UnixModeBits = 0755;
554         status->ParentVnode = 1;
555         status->ParentUnique = 1;
556         status->dataVersionHigh = afs_dynrootVersionHigh;
557     }
558 }
559
560 void
561 afs_GetDynrootMount(char **dynrootDir, int *dynrootLen,
562                     struct AFSFetchStatus *status)
563 {
564     ObtainReadLock(&afs_dynrootDirLock);
565     if (!afs_dynrootMountDir) {
566         ReleaseReadLock(&afs_dynrootDirLock);
567         afs_RebuildDynrootMount();
568         ObtainReadLock(&afs_dynrootDirLock);
569     }
570
571     if (dynrootDir)
572         *dynrootDir = afs_dynrootMountDir;
573     if (dynrootLen)
574         *dynrootLen = afs_dynrootMountDirLen;
575
576     if (status) {
577         memset(status, 0, sizeof(struct AFSFetchStatus));
578         status->FileType = Directory;
579         status->LinkCount = 1;
580         status->Length = afs_dynrootMountDirLen;
581         status->DataVersion = 1;
582         status->CallerAccess = PRSFS_LOOKUP | PRSFS_READ;
583         status->AnonymousAccess = PRSFS_LOOKUP | PRSFS_READ;
584         status->UnixModeBits = 0755;
585         status->ParentVnode = 1;
586         status->ParentUnique = 1;
587         status->dataVersionHigh = 0;
588     }
589 }
590
591 /*
592  * Puts back the dynroot read lock.
593  */
594 void
595 afs_PutDynroot(void)
596 {
597     ReleaseReadLock(&afs_dynrootDirLock);
598 }
599
600 /*
601  * Inform dynroot that a new vnode is being created.  Return value
602  * is non-zero if this vnode is handled by dynroot, in which case
603  * FetchStatus will be filled in.
604  */
605 int
606 afs_DynrootNewVnode(struct vcache *avc, struct AFSFetchStatus *status)
607 {
608     char *bp, tbuf[CVBS];
609
610     if (_afs_IsDynrootFid(&avc->f.fid)) {
611         if (!afs_dynrootEnable)
612             return 0;
613         afs_GetDynroot(0, 0, status);
614         afs_PutDynroot();
615         goto succeed;
616     }
617
618     if (afs_IsDynrootMount(avc)) {
619         afs_GetDynrootMount(0, 0, status);
620         afs_PutDynroot();
621         goto succeed;
622     }
623
624     /*
625      * Check if this is an entry under /afs, e.g. /afs/cellname.
626      */
627     if (avc->f.fid.Cell == afs_dynrootCell
628         && avc->f.fid.Fid.Volume == AFS_DYNROOT_VOLUME) {
629
630         struct cell *c;
631         struct cell_alias *ca;
632         int namelen, linklen, cellidx, rw;
633
634         memset(status, 0, sizeof(struct AFSFetchStatus));
635
636         status->FileType = SymbolicLink;
637         status->LinkCount = 1;
638         status->DataVersion = 1;
639         status->CallerAccess = PRSFS_LOOKUP | PRSFS_READ;
640         status->AnonymousAccess = PRSFS_LOOKUP | PRSFS_READ;
641         status->ParentVnode = 1;
642         status->ParentUnique = 1;
643
644         if (VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode) == VN_TYPE_SYMLINK) {
645             struct afs_dynSymlink *ts;
646             int index = VNUM_TO_VNID(avc->f.fid.Fid.Vnode);
647
648             ObtainReadLock(&afs_dynSymlinkLock);
649             ts = afs_dynSymlinkBase;
650             while (ts) {
651                 if (ts->index == index)
652                     break;
653                 ts = ts->next;
654             }
655
656             if (ts) {
657                 linklen = strlen(ts->target);
658                 avc->linkData = afs_osi_Alloc(linklen + 1);
659                 osi_Assert(avc->linkData != NULL);
660                 strcpy(avc->linkData, ts->target);
661
662                 status->Length = linklen;
663                 status->UnixModeBits = 0755;
664             }
665             ReleaseReadLock(&afs_dynSymlinkLock);
666
667             if (ts)
668                 goto succeed;
669
670             return 0;
671         }
672
673         if (VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode) != VN_TYPE_CELL
674             && VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode) != VN_TYPE_ALIAS
675             && VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode) != VN_TYPE_MOUNT) {
676             afs_warn("dynroot vnode inconsistency, unknown VNTYPE %d\n",
677                      VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode));
678             return 0;
679         }
680
681         cellidx = VNUM_TO_CIDX(avc->f.fid.Fid.Vnode);
682         rw = VNUM_TO_RW(avc->f.fid.Fid.Vnode);
683
684         if (VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode) == VN_TYPE_ALIAS) {
685             char *realName;
686
687             ca = afs_GetCellAlias(cellidx);
688             if (!ca) {
689                 afs_warn("dynroot vnode inconsistency, can't find alias %d\n",
690                          cellidx);
691                 return 0;
692             }
693
694             /*
695              * linkData needs to contain the name of the cell
696              * we're aliasing for.
697              */
698             realName = ca->cell;
699             if (!realName) {
700                 afs_warn("dynroot: alias %s missing real cell name\n",
701                          ca->alias);
702                 avc->linkData = afs_strdup("unknown");
703                 linklen = 7;
704             } else {
705                 int namelen = strlen(realName);
706                 linklen = rw + namelen;
707                 avc->linkData = afs_osi_Alloc(linklen + 1);
708                 osi_Assert(avc->linkData != NULL);
709                 strcpy(avc->linkData, rw ? "." : "");
710                 afs_strcat(avc->linkData, realName);
711             }
712
713             status->UnixModeBits = 0755;
714             afs_PutCellAlias(ca);
715
716         } else if (VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode) == VN_TYPE_MOUNT) {
717             c = afs_GetCellByIndex(cellidx, READ_LOCK);
718             if (!c) {
719                 afs_warn("dynroot vnode inconsistency, can't find cell %d\n",
720                          cellidx);
721                 return 0;
722             }
723
724             /*
725              * linkData needs to contain "%cell:volumeid"
726              */
727             namelen = strlen(c->cellName);
728             bp = afs_cv2string(&tbuf[CVBS], avc->f.fid.Fid.Unique);
729             linklen = 2 + namelen + strlen(bp);
730             avc->linkData = afs_osi_Alloc(linklen + 1);
731             osi_Assert(avc->linkData != NULL);
732             strcpy(avc->linkData, "%");
733             afs_strcat(avc->linkData, c->cellName);
734             afs_strcat(avc->linkData, ":");
735             afs_strcat(avc->linkData, bp);
736
737             status->UnixModeBits = 0644;
738             status->ParentVnode = AFS_DYNROOT_MOUNT_VNODE;
739             afs_PutCell(c, READ_LOCK);
740
741         } else {
742             c = afs_GetCellByIndex(cellidx, READ_LOCK);
743             if (!c) {
744                 afs_warn("dynroot vnode inconsistency, can't find cell %d\n",
745                          cellidx);
746                 return 0;
747             }
748
749             /*
750              * linkData needs to contain "#cell:root.cell" or "%cell:root.cell"
751              */
752             namelen = strlen(c->cellName);
753             linklen = 1 + namelen + 10;
754             avc->linkData = afs_osi_Alloc(linklen + 1);
755             osi_Assert(avc->linkData != NULL);
756             strcpy(avc->linkData, rw ? "%" : "#");
757             afs_strcat(avc->linkData, c->cellName);
758             afs_strcat(avc->linkData, ":root.cell");
759
760             status->UnixModeBits = 0644;
761             afs_PutCell(c, READ_LOCK);
762         }
763
764         status->Length = linklen;
765         goto succeed;
766     }
767
768     return 0;
769
770     /* make sure we set type correctly when we do this. used to stay VREG */
771  succeed:
772     switch (status->FileType) {
773     case File:
774         vSetType(avc, VREG);
775         break;
776     case Directory:
777         vSetType(avc, VDIR);
778         break;
779     case SymbolicLink:
780         if (afs_fakestat_enable && (avc->f.m.Mode & 0111) == 0)
781             vSetType(avc, VDIR);
782         else
783             vSetType(avc, VLNK);
784         break;
785     default:
786         /* shouldn't happen */
787       ;
788     }
789     return 1;
790 }
791
792 /*
793  * Make sure dynroot initialization has been done.
794  */
795 int
796 afs_InitDynroot(void)
797 {
798     if (afs_dynrootInit)
799         return 0;
800     AFS_RWLOCK_INIT(&afs_dynrootDirLock, "afs_dynrootDirLock");
801     AFS_RWLOCK_INIT(&afs_dynSymlinkLock, "afs_dynSymlinkLock");
802     afs_dynrootInit = 0;
803     return afs_dynrootCellInit();
804 }
805
806 /*
807  * Enable or disable dynroot.  Returns 0 if successful.
808  */
809 int
810 afs_SetDynrootEnable(int enable)
811 {
812     afs_dynrootEnable = enable;
813     return afs_InitDynroot();
814 }
815
816 /*
817  * Check if dynroot support is enabled.
818  */
819 int
820 afs_GetDynrootEnable(void)
821 {
822     return afs_dynrootEnable;
823 }
824
825 /*
826  * Remove a temporary symlink entry from /afs.
827  */
828 int
829 afs_DynrootVOPRemove(struct vcache *avc, afs_ucred_t *acred, char *aname)
830 {
831     struct afs_dynSymlink **tpps;
832     struct afs_dynSymlink *tps;
833     int found = 0;
834
835 #if defined(AFS_SUN510_ENV)
836     if (crgetruid(acred))
837 #else
838     if (afs_cr_uid(acred))
839 #endif
840         return EPERM;
841
842     ObtainWriteLock(&afs_dynSymlinkLock, 97);
843     tpps = &afs_dynSymlinkBase;
844     while (*tpps) {
845         tps = *tpps;
846         if (afs_strcasecmp(aname, tps->name) == 0) {
847             afs_osi_Free(tps->name, strlen(tps->name) + 1);
848             afs_osi_Free(tps->target, strlen(tps->target) + 1);
849             *tpps = tps->next;
850             afs_osi_Free(tps, sizeof(*tps));
851             afs_dynSymlinkIndex++;
852             found = 1;
853             break;
854         }
855         tpps = &(tps->next);
856     }
857     ReleaseWriteLock(&afs_dynSymlinkLock);
858     if (found) {
859         afs_DynrootInvalidate();
860         return 0;
861     }
862
863     if (afs_CellOrAliasExists(aname))
864         return EROFS;
865     else
866         return ENOENT;
867 }
868
869 /*
870  * Create a temporary symlink entry in /afs.
871  */
872 int
873 afs_DynrootVOPSymlink(struct vcache *avc, afs_ucred_t *acred,
874                       char *aname, char *atargetName)
875 {
876     struct afs_dynSymlink *tps;
877
878     if (afs_cr_uid(acred))
879         return EPERM;
880     if (afs_CellOrAliasExists(aname))
881         return EEXIST;
882
883     /* Check if it's already a symlink */
884     ObtainWriteLock(&afs_dynSymlinkLock, 91);
885     tps = afs_dynSymlinkBase;
886     while (tps) {
887         if (afs_strcasecmp(aname, tps->name) == 0) {
888             ReleaseWriteLock(&afs_dynSymlinkLock);
889             return EEXIST;
890         }
891         tps = tps->next;
892     }
893
894     /* Doesn't already exist -- go ahead and create it */
895     tps = afs_osi_Alloc(sizeof(*tps));
896     osi_Assert(tps != NULL);
897     tps->index = afs_dynSymlinkIndex++;
898     tps->next = afs_dynSymlinkBase;
899     tps->name = afs_osi_Alloc(strlen(aname) + 1);
900     osi_Assert(tps->name != NULL);
901     strcpy(tps->name, aname);
902     tps->target = afs_osi_Alloc(strlen(atargetName) + 1);
903     osi_Assert(tps->target != NULL);
904     strcpy(tps->target, atargetName);
905     afs_dynSymlinkBase = tps;
906     ReleaseWriteLock(&afs_dynSymlinkLock);
907
908     afs_DynrootInvalidate();
909     return 0;
910 }