bba3d42ec97bfb5fdda3e5f12529ae48976869d6
[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_GetDynrootFid
16  * afs_IsDynroot
17  * afs_RefreshDynroot
18  * afs_GetDynroot
19  * afs_PutDynroot
20  * afs_DynrootNewVnode
21  * afs_SetDynrootEnable
22  * afs_GetDynrootEnable
23  * afs_DynrootVOPRemove
24  * afs_DynrootVOPSymlink
25  *
26  */
27
28 #include <afsconfig.h>
29 #include "../afs/param.h"
30
31 #include "../afs/stds.h"
32 #include "../afs/sysincludes.h" /* Standard vendor system headers */
33 #include "../afs/afsincludes.h"
34 #include "../afs/afs_osi.h"
35 #include "../afsint/afsint.h"
36 #include "../afs/lock.h"
37
38 #include "../afs/prs_fs.h"
39 #include "../afs/dir.h"
40
41 #define AFS_DYNROOT_CELL        1
42 #define AFS_DYNROOT_VOLUME      1
43 #define AFS_DYNROOT_VNODE       1
44 #define AFS_DYNROOT_UNIQUE      1
45
46 /*
47  * Vnode numbers in dynroot are composed of a type field (upper 8 bits)
48  * and a type-specific identifier in the lower 24 bits.
49  */
50 #define VN_TYPE_CELL            0x01    /* Corresponds to a struct cell */
51 #define VN_TYPE_SYMLINK         0x02    /* User-created symlink in /afs */
52
53 #define VNUM_TO_VNTYPE(vnum)    ((vnum) >> 24)
54 #define VNUM_TO_VNID(vnum)      ((vnum) & 0x00ffffff)
55 #define VNUM_FROM_TYPEID(type, id) \
56                                 ((type) << 24 | (id))
57 #define VNUM_TO_CIDX(vnum)      (VNUM_TO_VNID(vnum) >> 2)
58 #define VNUM_TO_RW(vnum)        (VNUM_TO_VNID(vnum) >> 1 & 1)
59 #define VNUM_FROM_CIDX_RW(cidx, rw) \
60                                 VNUM_FROM_TYPEID(VN_TYPE_CELL, \
61                                                  ((cidx) << 2 | (rw) << 1))
62
63 static int afs_dynrootEnable = 0;
64
65 static afs_rwlock_t afs_dynrootDirLock;
66 /* Start of variables protected by afs_dynrootDirLock */
67 static char *afs_dynrootDir = NULL;
68 static int afs_dynrootDirLen;
69 static int afs_dynrootDirLinkcnt;
70 static int afs_dynrootCellCount;
71 static int afs_dynrootVersion = 1;
72 static int afs_dynrootVersionHigh = 1;
73 /* End of variables protected by afs_dynrootDirLock */
74
75 /* A dynamically-created symlink in a dynroot /afs */
76 struct afs_dynSymlink {
77     struct afs_dynSymlink *next;
78     int index;
79     char *name;
80     char *target;
81 };
82
83 static afs_rwlock_t afs_dynSymlinkLock;
84 /* Start of variables protected by afs_dynSymlinkLock */
85 static struct afs_dynSymlink *afs_dynSymlinkBase = NULL;
86 static int afs_dynSymlinkIndex = 0;
87 /* End of variables protected by afs_dynSymlinkLock */
88
89 extern afs_int32 afs_cellindex;
90 extern afs_rwlock_t afs_xvcache;
91
92 /*
93  * Returns non-zero iff fid corresponds to the top of the dynroot volume.
94  */
95 int
96 afs_IsDynrootFid(struct VenusFid *fid)
97 {
98     return
99         (afs_dynrootEnable &&
100          fid->Cell       == AFS_DYNROOT_CELL   &&
101          fid->Fid.Volume == AFS_DYNROOT_VOLUME &&
102          fid->Fid.Vnode  == AFS_DYNROOT_VNODE  &&
103          fid->Fid.Unique == AFS_DYNROOT_UNIQUE);
104 }
105
106 /*
107  * Obtain the magic dynroot volume Fid.
108  */
109 void
110 afs_GetDynrootFid(struct VenusFid *fid) 
111 {
112     fid->Cell       = AFS_DYNROOT_CELL;
113     fid->Fid.Volume = AFS_DYNROOT_VOLUME;
114     fid->Fid.Vnode  = AFS_DYNROOT_VNODE;
115     fid->Fid.Unique = AFS_DYNROOT_UNIQUE;
116 }
117
118 /*
119  * Returns non-zero iff avc is a pointer to the dynroot /afs vnode.
120  */
121 int
122 afs_IsDynroot(avc)
123     struct vcache *avc;
124 {
125     return afs_IsDynrootFid(&avc->fid);
126 }
127
128 /*
129  * Add directory entry by given name to a directory.  Assumes the
130  * caller has allocated the directory to be large enough to hold
131  * the necessary entry.
132  */
133 static void
134 afs_dynroot_addDirEnt(dirHeader, curPageP, curChunkP, name, vnode)
135     struct DirHeader *dirHeader;
136     int *curPageP;
137     int *curChunkP;
138     char *name;
139     int vnode;
140 {
141     char *dirBase = (char *) dirHeader;
142     struct PageHeader *pageHeader;
143     struct DirEntry *dirEntry;
144     int sizeOfEntry, i, t1, t2;
145     int curPage = *curPageP;
146     int curChunk = *curChunkP;
147     int didNewPage = 0;
148
149     /*
150      * Check if we need to flip pages..  If so, init the new page.
151      */
152     sizeOfEntry = afs_dir_NameBlobs(name);
153     if (curChunk + sizeOfEntry > EPP) {
154         curPage++;
155         curChunk = 1;
156         didNewPage = 1;
157     }
158
159     pageHeader = (struct PageHeader *) (dirBase + curPage * AFS_PAGESIZE);
160     if (didNewPage) {
161         pageHeader->pgcount = 0;
162         pageHeader->tag = htons(1234);
163         pageHeader->freecount = 0;
164         pageHeader->freebitmap[0] = 0x01;
165         for (i = 1; i < EPP/8; i++)
166             pageHeader->freebitmap[i] = 0;
167
168         dirHeader->alloMap[curPage] = EPP - 1;
169     }
170
171     dirEntry = (struct DirEntry *) (pageHeader + curChunk);
172     dirEntry->flag        = 1;
173     dirEntry->length      = 0;
174     dirEntry->next        = 0;
175     dirEntry->fid.vnode   = htonl(vnode);
176     dirEntry->fid.vunique = htonl(1);
177     strcpy(dirEntry->name, name);
178
179     for (i = curChunk; i < curChunk + sizeOfEntry; i++) {
180         t1 = i / 8;
181         t2 = i % 8;
182         pageHeader->freebitmap[t1] |= (1 << t2);
183     }
184
185     /*
186      * Add the new entry to the correct hash chain.
187      */
188     i = DirHash(name);
189     dirEntry->next = dirHeader->hashTable[i];
190     dirHeader->hashTable[i] = htons(curPage * EPP + curChunk);
191
192     curChunk += sizeOfEntry;
193     dirHeader->alloMap[curPage] -= sizeOfEntry;
194
195     *curPageP = curPage;
196     *curChunkP = curChunk;
197 }
198
199 /*
200  * Regenerates the dynroot contents from the current list of
201  * cells.  Useful when the list of cells has changed due to
202  * an AFSDB lookup, for instance.
203  */
204 void
205 afs_RefreshDynroot()
206 {
207     int cellidx, maxcellidx, i;
208     struct cell *c;
209     int curChunk, curPage;
210     int dirSize, sizeOfCurEntry;
211     char *newDir, *dotCell;
212     struct DirHeader *dirHeader;
213     struct PageHeader *pageHeader;
214     struct DirEntry *dirEntry;
215     int doFlush = 0;
216     int linkCount = 0;
217     struct afs_dynSymlink *ts;
218     int newCellCount;
219
220     /*
221      * Save afs_cellindex here, in case it changes between the
222      * two loops.
223      */
224     maxcellidx = afs_cellindex;
225
226     /*
227      * Compute the amount of space we need for the fake dir
228      */
229     curChunk = 13;
230     curPage = 0;
231
232     for (cellidx = 0; cellidx < maxcellidx; cellidx++) {
233         c = afs_GetCellByIndex(cellidx, READ_LOCK, 0 /* don't refresh */);
234         if (!c) continue;
235
236         sizeOfCurEntry = afs_dir_NameBlobs(c->cellName);
237         if (curChunk + sizeOfCurEntry > EPP) {
238             curPage++;
239             curChunk = 1;
240         }
241         curChunk += sizeOfCurEntry;
242
243         dotCell = afs_osi_Alloc(strlen(c->cellName) + 2);
244         strcpy(dotCell, ".");
245         strcat(dotCell, c->cellName);
246         sizeOfCurEntry = afs_dir_NameBlobs(dotCell);
247         if (curChunk + sizeOfCurEntry > EPP) {
248             curPage++;
249             curChunk = 1;
250         }
251         curChunk += sizeOfCurEntry;
252
253         afs_PutCell(c, READ_LOCK);
254     }
255
256     ObtainReadLock(&afs_dynSymlinkLock);
257     ts = afs_dynSymlinkBase;
258     while (ts) {
259         sizeOfCurEntry = afs_dir_NameBlobs(ts->name);
260         if (curChunk + sizeOfCurEntry > EPP) {
261             curPage++;
262             curChunk = 1;
263         }
264         curChunk += sizeOfCurEntry;
265         ts = ts->next;
266     }
267
268     dirSize = (curPage + 1) * AFS_PAGESIZE;
269     newDir = afs_osi_Alloc(dirSize);
270
271     /*
272      * Now actually construct the directory.
273      */
274     curChunk = 13;
275     curPage = 0;
276     dirHeader = (struct DirHeader *) newDir;
277
278     dirHeader->header.pgcount = 0;
279     dirHeader->header.tag = htons(1234);
280     dirHeader->header.freecount = 0;
281
282     dirHeader->header.freebitmap[0] = 0xff;
283     dirHeader->header.freebitmap[1] = 0x1f;
284     for (i = 2; i < EPP/8; i++)
285         dirHeader->header.freebitmap[i] = 0;
286     dirHeader->alloMap[0] = EPP - DHE - 1;
287     for (i = 1; i < MAXPAGES; i++)
288         dirHeader->alloMap[i] = EPP;
289     for (i = 0; i < NHASHENT; i++)
290         dirHeader->hashTable[i] = 0;
291
292     /* Install "." and ".." */
293     afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, ".", 1);
294     afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, "..", 1);
295     linkCount += 2;
296
297     for (cellidx = 0; cellidx < maxcellidx; cellidx++) {
298         c = afs_GetCellByIndex(cellidx, READ_LOCK, 0 /* don't refresh */);
299         afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk,
300                               c->cellName, VNUM_FROM_CIDX_RW(cellidx, 0));
301
302         dotCell = afs_osi_Alloc(strlen(c->cellName) + 2);
303         strcpy(dotCell, ".");
304         strcat(dotCell, c->cellName);
305         afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk,
306                               dotCell, VNUM_FROM_CIDX_RW(cellidx, 1));
307
308         if (!(c->states & CAlias)) linkCount += 2;
309         afs_PutCell(c, READ_LOCK);
310     }
311
312     ts = afs_dynSymlinkBase;
313     while (ts) {
314         int vnum = VNUM_FROM_TYPEID(VN_TYPE_SYMLINK, ts->index);
315         afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk,
316                               ts->name, vnum);
317         ts = ts->next;
318     }
319
320     newCellCount = maxcellidx + afs_dynSymlinkIndex;
321     ReleaseReadLock(&afs_dynSymlinkLock);
322
323     ObtainWriteLock(&afs_dynrootDirLock, 549);
324     if (afs_dynrootDir) afs_osi_Free(afs_dynrootDir, afs_dynrootDirLen);
325     afs_dynrootDir = newDir;
326     afs_dynrootDirLen = dirSize;
327     afs_dynrootDirLinkcnt = linkCount;
328     if (afs_dynrootCellCount != newCellCount) {
329         /*
330          * New cells/symlinks added -- bump data version, invalidate vcache.
331          */
332         afs_dynrootCellCount = newCellCount;
333         afs_dynrootVersion++;
334         afs_dynrootVersionHigh = osi_Time();
335         doFlush = 1;
336     }
337     ReleaseWriteLock(&afs_dynrootDirLock);
338
339     if (doFlush) {
340         afs_int32 retry;
341         struct vcache *tvc;
342         struct VenusFid tfid;
343
344         afs_GetDynrootFid(&tfid);
345         do {
346             retry = 0;
347             ObtainReadLock(&afs_xvcache);
348             tvc = afs_FindVCache(&tfid, 0, 0, &retry, 0);
349             ReleaseReadLock(&afs_xvcache);
350         } while (retry);
351         if (tvc) {
352             tvc->states &= ~(CStatd | CUnique);
353             osi_dnlc_purgedp(tvc);
354             afs_PutVCache(tvc);
355         }
356     }
357 }
358
359 /*
360  * Returns a pointer to the base of the dynroot directory in memory,
361  * length thereof, and a FetchStatus.
362  */
363 void
364 afs_GetDynroot(dynrootDir, dynrootLen, status)
365     char **dynrootDir;
366     int *dynrootLen;
367     struct AFSFetchStatus *status;
368 {
369     ObtainReadLock(&afs_dynrootDirLock);
370     if (!afs_dynrootDir) {
371         ReleaseReadLock(&afs_dynrootDirLock);
372         afs_RefreshDynroot();
373         ObtainReadLock(&afs_dynrootDirLock);
374     }
375
376     if (dynrootDir) *dynrootDir = afs_dynrootDir;
377     if (dynrootLen) *dynrootLen = afs_dynrootDirLen;
378
379     if (status) {
380         memset(status, 0, sizeof(struct AFSFetchStatus));
381         status->FileType        = Directory;
382         status->LinkCount       = afs_dynrootDirLinkcnt;
383         status->Length          = afs_dynrootDirLen;
384         status->DataVersion     = afs_dynrootVersion;
385         status->CallerAccess    = PRSFS_LOOKUP | PRSFS_READ;
386         status->AnonymousAccess = PRSFS_LOOKUP | PRSFS_READ;
387         status->UnixModeBits    = 0755;
388         status->ParentVnode     = 1;
389         status->ParentUnique    = 1;
390         status->dataVersionHigh = afs_dynrootVersionHigh;
391     }
392 }
393
394 /*
395  * Puts back the dynroot read lock.
396  */
397 void
398 afs_PutDynroot()
399 {
400     ReleaseReadLock(&afs_dynrootDirLock);
401 }
402
403 /*
404  * Inform dynroot that a new vnode is being created.  Return value
405  * is non-zero if this vnode is handled by dynroot, in which case
406  * FetchStatus will be filled in.
407  */
408 int
409 afs_DynrootNewVnode(avc, status)
410     struct vcache *avc;
411     struct AFSFetchStatus *status;
412 {
413     if (!afs_dynrootEnable) return 0;
414
415     if (afs_IsDynroot(avc)) {
416         afs_GetDynroot(0, 0, status);
417         afs_PutDynroot();
418         return 1;
419     }
420
421     /*
422      * Check if this is an entry under /afs, e.g. /afs/cellname.
423      */
424     if (avc->fid.Cell       == AFS_DYNROOT_CELL &&
425         avc->fid.Fid.Volume == AFS_DYNROOT_VOLUME) {
426
427         struct cell *c;
428         int namelen, linklen, cellidx, rw;
429
430         memset(status, 0, sizeof(struct AFSFetchStatus));
431
432         status->FileType        = SymbolicLink;
433         status->LinkCount       = 1;
434         status->DataVersion     = 1;
435         status->CallerAccess    = PRSFS_LOOKUP | PRSFS_READ;
436         status->AnonymousAccess = PRSFS_LOOKUP | PRSFS_READ;
437         status->ParentVnode     = 1;
438         status->ParentUnique    = 1;
439
440         if (VNUM_TO_VNTYPE(avc->fid.Fid.Vnode) == VN_TYPE_SYMLINK) {
441             struct afs_dynSymlink *ts;
442             int index = VNUM_TO_VNID(avc->fid.Fid.Vnode);
443
444             ObtainReadLock(&afs_dynSymlinkLock);
445             ts = afs_dynSymlinkBase;
446             while (ts) {
447                 if (ts->index == index) break;
448                 ts = ts->next;
449             }
450
451             if (ts) {
452                 linklen = strlen(ts->target);
453                 avc->linkData = afs_osi_Alloc(linklen + 1);
454                 strcpy(avc->linkData, ts->target);
455
456                 status->Length       = linklen;
457                 status->UnixModeBits = 0755;
458             }
459             ReleaseReadLock(&afs_dynSymlinkLock);
460
461             return ts ? 1 : 0;
462         }
463
464         if (VNUM_TO_VNTYPE(avc->fid.Fid.Vnode) != VN_TYPE_CELL) {
465             afs_warn("dynroot vnode inconsistency, unknown VNTYPE %d\n",
466                      VNUM_TO_VNTYPE(avc->fid.Fid.Vnode));
467             return 0;
468         }
469
470         cellidx = VNUM_TO_CIDX(avc->fid.Fid.Vnode);
471         rw = VNUM_TO_RW(avc->fid.Fid.Vnode);
472
473         c = afs_GetCellByIndex(cellidx, READ_LOCK, 1 /* refresh */);
474         if (!c) {
475             afs_warn("dynroot vnode inconsistency, can't find cell %d\n",
476                      cellidx);
477             return 0;
478         }
479
480         if (c->states & CAlias) {
481             /*
482              * linkData needs to contain the name of the cell
483              * we're aliasing for.
484              */
485             char *realName = c->realName;
486
487             if (!realName) {
488                 afs_warn("dynroot: alias %s missing real cell name\n",
489                          c->cellName);
490                 linklen = 7;
491                 avc->linkData = afs_osi_Alloc(linklen + 1);
492                 strcpy(avc->linkData, "unknown");
493             } else {
494                 int namelen = strlen(realName);
495                 linklen = rw + namelen;
496                 avc->linkData = afs_osi_Alloc(linklen + 1);
497                 strcpy(avc->linkData, rw ? "." : "");
498                 strcat(avc->linkData, realName);
499             }
500
501             status->UnixModeBits = 0755;
502         } else {
503             /*
504              * linkData needs to contain "#cell:root.cell" or "%cell:root.cell"
505              */
506             namelen = strlen(c->cellName);
507             linklen = 1 + namelen + 10;
508             avc->linkData = afs_osi_Alloc(linklen + 1);
509             strcpy(avc->linkData, rw ? "%" : "#");
510             strcat(avc->linkData, c->cellName);
511             strcat(avc->linkData, ":root.cell");
512
513             status->UnixModeBits = 0644;
514         }
515
516         status->Length = linklen;
517         afs_PutCell(c, READ_LOCK);
518         return 1;
519     }
520
521     return 0;
522 }
523
524 /*
525  * Enable or disable dynroot.  Returns 0 if successful.
526  */
527 int
528 afs_SetDynrootEnable(enable)
529     int enable;
530 {
531     afs_dynrootEnable = enable;
532     return 0;
533 }
534
535 /*
536  * Check if dynroot support is enabled.
537  */
538 int
539 afs_GetDynrootEnable()
540 {
541     return afs_dynrootEnable;
542 }
543
544 /*
545  * Remove a temporary symlink entry from /afs.
546  */
547 int
548 afs_DynrootVOPRemove(avc, acred, aname)
549     struct vcache *avc;
550     struct AFS_UCRED *acred;
551     char *aname;
552 {
553     struct afs_dynSymlink **tpps;
554     struct afs_dynSymlink *tps;
555     struct cell *c;
556     int found = 0;
557
558     if (acred->cr_uid)
559         return EPERM;
560
561     ObtainWriteLock(&afs_dynSymlinkLock, 97);
562     tpps = &afs_dynSymlinkBase;
563     while (*tpps) {
564         tps = *tpps;
565         if (afs_strcasecmp(aname, tps->name) == 0) {
566             afs_osi_Free(tps->name, strlen(tps->name) + 1);
567             afs_osi_Free(tps->target, strlen(tps->target) + 1);
568             *tpps = tps->next;
569             afs_osi_Free(tps, sizeof(*tps));
570             afs_dynSymlinkIndex++;
571             found = 1;
572             break;
573         }
574         tpps = &(tps->next);
575     }
576     ReleaseWriteLock(&afs_dynSymlinkLock);
577     if (found) {
578         afs_RefreshDynroot();
579         return 0;
580     }
581
582     /* Check if this is an actual cell? */
583     c = afs_GetCellByName2(aname, READ_LOCK, 0 /* no AFSDB */);
584     if (c) {
585         afs_PutCell(c, READ_LOCK);
586         return EROFS;
587     } else {
588         return ENOENT;
589     }
590 }
591
592 /*
593  * Create a temporary symlink entry in /afs.
594  */
595 int
596 afs_DynrootVOPSymlink(avc, acred, aname, atargetName)
597     struct vcache *avc;
598     struct AFS_UCRED *acred;
599     char *aname;
600     char *atargetName;
601 {
602     struct afs_dynSymlink *tps;
603     struct cell *c;
604
605     if (acred->cr_uid)
606         return EPERM;
607
608     /* Check if it's already a cell */
609     c = afs_GetCellByName2(aname, READ_LOCK, 0 /* no AFSDB */);
610     if (c) {
611         afs_PutCell(c, READ_LOCK);
612         return EEXIST;
613     }
614
615     /* Check if it's already a symlink */
616     ObtainWriteLock(&afs_dynSymlinkLock, 91);
617     tps = afs_dynSymlinkBase;
618     while (tps) {
619         if (afs_strcasecmp(aname, tps->name) == 0) {
620             ReleaseWriteLock(&afs_dynSymlinkLock);
621             return EEXIST;
622         }
623         tps = tps->next;
624     }
625
626     /* Doesn't already exist -- go ahead and create it */
627     tps = afs_osi_Alloc(sizeof(*tps));
628     tps->index = afs_dynSymlinkIndex++;
629     tps->next = afs_dynSymlinkBase;
630     tps->name = afs_osi_Alloc(strlen(aname) + 1);
631     strcpy(tps->name, aname);
632     tps->target = afs_osi_Alloc(strlen(atargetName) + 1);
633     strcpy(tps->target, atargetName);
634     afs_dynSymlinkBase = tps;
635     ReleaseWriteLock(&afs_dynSymlinkLock);
636
637     afs_RefreshDynroot();
638     return 0;
639 }