static int afs_dynrootEnable = 0;
static int afs_dynrootCell = 0;
-static afs_rwlock_t afs_dynrootDirLock;
+afs_rwlock_t afs_dynrootDirLock;
/* Start of variables protected by afs_dynrootDirLock */
static char *afs_dynrootDir = NULL;
static int afs_dynrootDirLen;
char *target;
};
-static afs_rwlock_t afs_dynSymlinkLock;
+afs_rwlock_t afs_dynSymlinkLock;
/* Start of variables protected by afs_dynSymlinkLock */
static struct afs_dynSymlink *afs_dynSymlinkBase = NULL;
static int afs_dynSymlinkIndex = 0;
* Set up a cell for dynroot if it's not there yet.
*/
static int
-afs_dynrootCellInit()
+afs_dynrootCellInit(void)
{
if (!afs_dynrootCell) {
- afs_int32 cellHosts[MAXCELLHOSTS];
+ afs_int32 cellHosts[AFS_MAXCELLHOSTS];
struct cell *tc;
int code;
int
afs_IsDynroot(struct vcache *avc)
{
- return afs_IsDynrootFid(&avc->fid);
+ return afs_IsDynrootFid(&avc->f.fid);
}
int
afs_IsDynrootMount(struct vcache *avc)
{
- return afs_IsDynrootMountFid(&avc->fid);
+ return afs_IsDynrootMountFid(&avc->f.fid);
}
int
afs_IsDynrootAny(struct vcache *avc)
{
- return afs_IsDynrootAnyFid(&avc->fid);
+ return afs_IsDynrootAnyFid(&avc->f.fid);
}
/*
/*
* Add the new entry to the correct hash chain.
*/
- i = DirHash(name);
+ i = afs_dir_DirHash(name);
dirEntry->next = dirHeader->hashTable[i];
dirHeader->hashTable[i] = htons(curPage * EPP + curChunk);
ReleaseReadLock(&afs_xvcache);
} while (retry);
if (tvc) {
- tvc->states &= ~(CStatd | CUnique);
+ tvc->f.states &= ~(CStatd | CUnique);
osi_dnlc_purgedp(tvc);
afs_PutVCache(tvc);
}
c = afs_GetCellByIndex(cellidx, READ_LOCK);
if (!c)
break;
- if (c->cellNum == afs_dynrootCell)
+ if ((c->cellNum == afs_dynrootCell) || (c->states & CHush)) {
+ afs_PutCell(c, READ_LOCK);
continue;
-
+ }
dotLen = strlen(c->cellName) + 2;
dotCell = afs_osi_Alloc(dotLen);
+ osi_Assert(dotCell != NULL);
strcpy(dotCell, ".");
afs_strcat(dotCell, c->cellName);
dotLen = strlen(ca->alias) + 2;
dotCell = afs_osi_Alloc(dotLen);
+ osi_Assert(dotCell != NULL);
strcpy(dotCell, ".");
afs_strcat(dotCell, ca->alias);
dirSize = (curPage + 1) * AFS_PAGESIZE;
newDir = afs_osi_Alloc(dirSize);
+ osi_Assert(newDir != NULL);
/*
* Now actually construct the directory.
dirHeader->alloMap[0] = EPP - DHE - 1;
for (i = 1; i < MAXPAGES; i++)
dirHeader->alloMap[i] = EPP;
- for (i = 0; i < NHASHENT; i++)
- dirHeader->hashTable[i] = 0;
+ memset(dirHeader->hashTable, 0, NHASHENT * sizeof(dirHeader->hashTable[0]));
/* Install ".", "..", and the dynamic mount directory */
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, ".", 1);
c = afs_GetCellByIndex(cellidx, READ_LOCK);
if (!c)
continue;
- if (c->cellNum == afs_dynrootCell)
+ if ((c->cellNum == afs_dynrootCell) || (c->states & CHush)) {
+ afs_PutCell(c, READ_LOCK);
continue;
+ }
dotLen = strlen(c->cellName) + 2;
dotCell = afs_osi_Alloc(dotLen);
+ osi_Assert(dotCell != NULL);
strcpy(dotCell, ".");
afs_strcat(dotCell, c->cellName);
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, c->cellName,
dotLen = strlen(ca->alias) + 2;
dotCell = afs_osi_Alloc(dotLen);
+ osi_Assert(dotCell != NULL);
strcpy(dotCell, ".");
afs_strcat(dotCell, ca->alias);
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, ca->alias,
struct DirHeader *dirHeader;
newDir = afs_osi_Alloc(AFS_PAGESIZE);
+ osi_Assert(newDir != NULL);
/*
* Now actually construct the directory.
dirHeader->alloMap[0] = EPP - DHE - 1;
for (i = 1; i < MAXPAGES; i++)
dirHeader->alloMap[i] = EPP;
- for (i = 0; i < NHASHENT; i++)
- dirHeader->hashTable[i] = 0;
+ memset(dirHeader->hashTable, 0, NHASHENT * sizeof(dirHeader->hashTable[0]));
/* Install "." and ".." */
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, ".", 1);
{
char *bp, tbuf[CVBS];
- if (_afs_IsDynrootFid(&avc->fid)) {
+ if (_afs_IsDynrootFid(&avc->f.fid)) {
if (!afs_dynrootEnable)
return 0;
afs_GetDynroot(0, 0, status);
afs_PutDynroot();
- return 1;
+ goto succeed;
}
if (afs_IsDynrootMount(avc)) {
afs_GetDynrootMount(0, 0, status);
afs_PutDynroot();
- return 1;
+ goto succeed;
}
/*
* Check if this is an entry under /afs, e.g. /afs/cellname.
*/
- if (avc->fid.Cell == afs_dynrootCell
- && avc->fid.Fid.Volume == AFS_DYNROOT_VOLUME) {
+ if (avc->f.fid.Cell == afs_dynrootCell
+ && avc->f.fid.Fid.Volume == AFS_DYNROOT_VOLUME) {
struct cell *c;
struct cell_alias *ca;
status->ParentVnode = 1;
status->ParentUnique = 1;
- if (VNUM_TO_VNTYPE(avc->fid.Fid.Vnode) == VN_TYPE_SYMLINK) {
+ if (VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode) == VN_TYPE_SYMLINK) {
struct afs_dynSymlink *ts;
- int index = VNUM_TO_VNID(avc->fid.Fid.Vnode);
+ int index = VNUM_TO_VNID(avc->f.fid.Fid.Vnode);
ObtainReadLock(&afs_dynSymlinkLock);
ts = afs_dynSymlinkBase;
if (ts) {
linklen = strlen(ts->target);
avc->linkData = afs_osi_Alloc(linklen + 1);
+ osi_Assert(avc->linkData != NULL);
strcpy(avc->linkData, ts->target);
status->Length = linklen;
}
ReleaseReadLock(&afs_dynSymlinkLock);
- return ts ? 1 : 0;
+ if (ts)
+ goto succeed;
+
+ return 0;
}
- if (VNUM_TO_VNTYPE(avc->fid.Fid.Vnode) != VN_TYPE_CELL
- && VNUM_TO_VNTYPE(avc->fid.Fid.Vnode) != VN_TYPE_ALIAS
- && VNUM_TO_VNTYPE(avc->fid.Fid.Vnode) != VN_TYPE_MOUNT) {
+ if (VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode) != VN_TYPE_CELL
+ && VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode) != VN_TYPE_ALIAS
+ && VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode) != VN_TYPE_MOUNT) {
afs_warn("dynroot vnode inconsistency, unknown VNTYPE %d\n",
- VNUM_TO_VNTYPE(avc->fid.Fid.Vnode));
+ VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode));
return 0;
}
- cellidx = VNUM_TO_CIDX(avc->fid.Fid.Vnode);
- rw = VNUM_TO_RW(avc->fid.Fid.Vnode);
+ cellidx = VNUM_TO_CIDX(avc->f.fid.Fid.Vnode);
+ rw = VNUM_TO_RW(avc->f.fid.Fid.Vnode);
- if (VNUM_TO_VNTYPE(avc->fid.Fid.Vnode) == VN_TYPE_ALIAS) {
+ if (VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode) == VN_TYPE_ALIAS) {
char *realName;
ca = afs_GetCellAlias(cellidx);
int namelen = strlen(realName);
linklen = rw + namelen;
avc->linkData = afs_osi_Alloc(linklen + 1);
+ osi_Assert(avc->linkData != NULL);
strcpy(avc->linkData, rw ? "." : "");
afs_strcat(avc->linkData, realName);
}
status->UnixModeBits = 0755;
afs_PutCellAlias(ca);
- } else if (VNUM_TO_VNTYPE(avc->fid.Fid.Vnode) == VN_TYPE_MOUNT) {
+ } else if (VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode) == VN_TYPE_MOUNT) {
c = afs_GetCellByIndex(cellidx, READ_LOCK);
if (!c) {
afs_warn("dynroot vnode inconsistency, can't find cell %d\n",
* linkData needs to contain "%cell:volumeid"
*/
namelen = strlen(c->cellName);
- bp = afs_cv2string(&tbuf[CVBS], avc->fid.Fid.Unique);
+ bp = afs_cv2string(&tbuf[CVBS], avc->f.fid.Fid.Unique);
linklen = 2 + namelen + strlen(bp);
avc->linkData = afs_osi_Alloc(linklen + 1);
+ osi_Assert(avc->linkData != NULL);
strcpy(avc->linkData, "%");
afs_strcat(avc->linkData, c->cellName);
afs_strcat(avc->linkData, ":");
namelen = strlen(c->cellName);
linklen = 1 + namelen + 10;
avc->linkData = afs_osi_Alloc(linklen + 1);
+ osi_Assert(avc->linkData != NULL);
strcpy(avc->linkData, rw ? "%" : "#");
afs_strcat(avc->linkData, c->cellName);
afs_strcat(avc->linkData, ":root.cell");
}
status->Length = linklen;
- return 1;
+ goto succeed;
}
return 0;
+
+ /* make sure we set type correctly when we do this. used to stay VREG */
+ succeed:
+ switch (status->FileType) {
+ case File:
+ vSetType(avc, VREG);
+ break;
+ case Directory:
+ vSetType(avc, VDIR);
+ break;
+ case SymbolicLink:
+ if (afs_fakestat_enable && (avc->f.m.Mode & 0111) == 0)
+ vSetType(avc, VDIR);
+ else
+ vSetType(avc, VLNK);
+ break;
+ default:
+ /* shouldn't happen */
+ ;
+ }
+ return 1;
}
/*
{
if (afs_dynrootInit)
return 0;
- RWLOCK_INIT(&afs_dynrootDirLock, "afs_dynrootDirLock");
- RWLOCK_INIT(&afs_dynSymlinkLock, "afs_dynSymlinkLock");
+ AFS_RWLOCK_INIT(&afs_dynrootDirLock, "afs_dynrootDirLock");
+ AFS_RWLOCK_INIT(&afs_dynSymlinkLock, "afs_dynSymlinkLock");
afs_dynrootInit = 0;
return afs_dynrootCellInit();
}
* Remove a temporary symlink entry from /afs.
*/
int
-afs_DynrootVOPRemove(struct vcache *avc, struct AFS_UCRED *acred, char *aname)
+afs_DynrootVOPRemove(struct vcache *avc, afs_ucred_t *acred, char *aname)
{
struct afs_dynSymlink **tpps;
struct afs_dynSymlink *tps;
int found = 0;
- if (acred->cr_uid)
+#if defined(AFS_SUN510_ENV)
+ if (crgetruid(acred))
+#else
+ if (afs_cr_uid(acred))
+#endif
return EPERM;
ObtainWriteLock(&afs_dynSymlinkLock, 97);
* Create a temporary symlink entry in /afs.
*/
int
-afs_DynrootVOPSymlink(struct vcache *avc, struct AFS_UCRED *acred,
+afs_DynrootVOPSymlink(struct vcache *avc, afs_ucred_t *acred,
char *aname, char *atargetName)
{
struct afs_dynSymlink *tps;
- if (acred->cr_uid)
+ if (afs_cr_uid(acred))
return EPERM;
if (afs_CellOrAliasExists(aname))
return EEXIST;
/* Doesn't already exist -- go ahead and create it */
tps = afs_osi_Alloc(sizeof(*tps));
+ osi_Assert(tps != NULL);
tps->index = afs_dynSymlinkIndex++;
tps->next = afs_dynSymlinkBase;
tps->name = afs_osi_Alloc(strlen(aname) + 1);
+ osi_Assert(tps->name != NULL);
strcpy(tps->name, aname);
tps->target = afs_osi_Alloc(strlen(atargetName) + 1);
+ osi_Assert(tps->target != NULL);
strcpy(tps->target, atargetName);
afs_dynSymlinkBase = tps;
ReleaseWriteLock(&afs_dynSymlinkLock);
git://git.openafs.org / openafs.git / blobdiff