/**
* Init a new dynroot volume.
* @param Volume FID.
* @return Volume or NULL if not found.
*/
static struct volume *
afs_NewDynrootVolume(struct VenusFid *fid)
{
struct cell *tcell;
struct volume *tv;
struct vldbentry *tve;
char *bp, tbuf[CVBS];
tcell = afs_GetCell(fid->Cell, READ_LOCK);
if (!tcell)
return NULL;
tve = afs_osi_Alloc(sizeof(*tve));
osi_Assert(tve != NULL);
if (!(tcell->states & CHasVolRef))
tcell->states |= CHasVolRef;
bp = afs_cv2string(&tbuf[CVBS], fid->Fid.Volume);
memset(tve, 0, sizeof(*tve));
strcpy(tve->name, "local-dynroot");
tve->volumeId[ROVOL] = fid->Fid.Volume;
tve->flags = VLF_ROEXISTS;
tv = afs_SetupVolume(0, bp, tve, tcell, 0, 0, 0);
afs_PutCell(tcell, READ_LOCK);
afs_osi_Free(tve, sizeof(*tve));
return tv;
}
/**
* Note that areq may be null, in which case we don't bother to set any
* request status information.
* @param afid Volume FID.
* @param areq Request type.
* @param locktype Lock to be used.
* @return Volume or NULL if no result.
*/
struct volume *
afs_GetVolume(struct VenusFid *afid, struct vrequest *areq,
afs_int32 locktype)
{
struct volume *tv;
char *bp, tbuf[CVBS];
AFS_STATCNT(afs_GetVolume);
tv = afs_FindVolume(afid, locktype);
if (!tv) {
/* Do a dynroot check and add dynroot volume if found. */
if (afs_IsDynrootAnyFid(afid)) {
tv = afs_NewDynrootVolume(afid);
} else {
bp = afs_cv2string(&tbuf[CVBS], afid->Fid.Volume);
tv = afs_NewVolumeByName(bp, afid->Cell, 0, areq, locktype);
}
}
return tv;
} /*afs_GetVolume */
/*
* Inform dynroot that a new vnode is being created. Return value
* is non-zero if this vnode is handled by dynroot, in which case
* FetchStatus will be filled in.
*/
int
afs_DynrootNewVnode(struct vcache *avc, struct AFSFetchStatus *status)
{
char *bp, tbuf[CVBS];
if (_afs_IsDynrootFid(&avc->f.fid)) {
if (!afs_dynrootEnable)
return 0;
afs_GetDynroot(0, 0, status);
afs_PutDynroot();
return 1;
}
if (afs_IsDynrootMount(avc)) {
afs_GetDynrootMount(0, 0, status);
afs_PutDynroot();
return 1;
}
/*
* Check if this is an entry under /afs, e.g. /afs/cellname.
*/
if (avc->f.fid.Cell == afs_dynrootCell
&& avc->f.fid.Fid.Volume == AFS_DYNROOT_VOLUME) {
struct cell *c;
struct cell_alias *ca;
int namelen, linklen, cellidx, rw;
memset(status, 0, sizeof(struct AFSFetchStatus));
status->FileType = SymbolicLink;
status->LinkCount = 1;
status->DataVersion = 1;
status->CallerAccess = PRSFS_LOOKUP | PRSFS_READ;
status->AnonymousAccess = PRSFS_LOOKUP | PRSFS_READ;
status->ParentVnode = 1;
status->ParentUnique = 1;
if (VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode) == VN_TYPE_SYMLINK) {
struct afs_dynSymlink *ts;
int index = VNUM_TO_VNID(avc->f.fid.Fid.Vnode);
ObtainReadLock(&afs_dynSymlinkLock);
ts = afs_dynSymlinkBase;
while (ts) {
if (ts->index == index)
break;
ts = ts->next;
}
if (ts) {
linklen = strlen(ts->target);
avc->linkData = afs_osi_Alloc(linklen + 1);
strcpy(avc->linkData, ts->target);
status->Length = linklen;
status->UnixModeBits = 0755;
}
ReleaseReadLock(&afs_dynSymlinkLock);
return ts ? 1 : 0;
}
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->f.fid.Fid.Vnode));
return 0;
}
cellidx = VNUM_TO_CIDX(avc->f.fid.Fid.Vnode);
rw = VNUM_TO_RW(avc->f.fid.Fid.Vnode);
if (VNUM_TO_VNTYPE(avc->f.fid.Fid.Vnode) == VN_TYPE_ALIAS) {
char *realName;
ca = afs_GetCellAlias(cellidx);
if (!ca) {
afs_warn("dynroot vnode inconsistency, can't find alias %d\n",
cellidx);
return 0;
}
/*
* linkData needs to contain the name of the cell
* we're aliasing for.
*/
realName = ca->cell;
if (!realName) {
afs_warn("dynroot: alias %s missing real cell name\n",
ca->alias);
avc->linkData = afs_strdup("unknown");
linklen = 7;
} else {
int namelen = strlen(realName);
linklen = rw + namelen;
avc->linkData = afs_osi_Alloc(linklen + 1);
strcpy(avc->linkData, rw ? "." : "");
afs_strcat(avc->linkData, realName);
}
status->UnixModeBits = 0755;
afs_PutCellAlias(ca);
} 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",
cellidx);
return 0;
}
/*
* linkData needs to contain "%cell:volumeid"
*/
namelen = strlen(c->cellName);
bp = afs_cv2string(&tbuf[CVBS], avc->f.fid.Fid.Unique);
linklen = 2 + namelen + strlen(bp);
avc->linkData = afs_osi_Alloc(linklen + 1);
strcpy(avc->linkData, "%");
afs_strcat(avc->linkData, c->cellName);
afs_strcat(avc->linkData, ":");
afs_strcat(avc->linkData, bp);
status->UnixModeBits = 0644;
status->ParentVnode = AFS_DYNROOT_MOUNT_VNODE;
afs_PutCell(c, READ_LOCK);
} else {
c = afs_GetCellByIndex(cellidx, READ_LOCK);
if (!c) {
afs_warn("dynroot vnode inconsistency, can't find cell %d\n",
cellidx);
return 0;
}
/*
* linkData needs to contain "#cell:root.cell" or "%cell:root.cell"
*/
namelen = strlen(c->cellName);
linklen = 1 + namelen + 10;
avc->linkData = afs_osi_Alloc(linklen + 1);
strcpy(avc->linkData, rw ? "%" : "#");
afs_strcat(avc->linkData, c->cellName);
afs_strcat(avc->linkData, ":root.cell");
status->UnixModeBits = 0644;
afs_PutCell(c, READ_LOCK);
}
status->Length = linklen;
return 1;
}
return 0;
}
static int
VLDB_Same(struct VenusFid *afid, struct vrequest *areq)
{
struct vrequest treq;
struct afs_conn *tconn;
int i, type = 0;
union {
struct vldbentry tve;
struct nvldbentry ntve;
struct uvldbentry utve;
} *v;
struct volume *tvp;
struct cell *tcell;
char *bp, tbuf[CVBS]; /* biggest volume id is 2^32, ~ 4*10^9 */
unsigned int changed;
struct server *(oldhosts[NMAXNSERVERS]);
AFS_STATCNT(CheckVLDB);
afs_FinalizeReq(areq);
if ((i = afs_InitReq(&treq, afs_osi_credp)))
return DUNNO;
v = afs_osi_Alloc(sizeof(*v));
tcell = afs_GetCell(afid->Cell, READ_LOCK);
bp = afs_cv2string(&tbuf[CVBS], afid->Fid.Volume);
do {
VSleep(2); /* Better safe than sorry. */
tconn =
afs_ConnByMHosts(tcell->cellHosts, tcell->vlport, tcell->cellNum,
&treq, SHARED_LOCK);
if (tconn) {
if (tconn->srvr->server->flags & SNO_LHOSTS) {
type = 0;
RX_AFS_GUNLOCK();
i = VL_GetEntryByNameO(tconn->id, bp, &v->tve);
RX_AFS_GLOCK();
} else if (tconn->srvr->server->flags & SYES_LHOSTS) {
type = 1;
RX_AFS_GUNLOCK();
i = VL_GetEntryByNameN(tconn->id, bp, &v->ntve);
RX_AFS_GLOCK();
} else {
type = 2;
RX_AFS_GUNLOCK();
i = VL_GetEntryByNameU(tconn->id, bp, &v->utve);
RX_AFS_GLOCK();
if (!(tconn->srvr->server->flags & SVLSRV_UUID)) {
if (i == RXGEN_OPCODE) {
type = 1;
RX_AFS_GUNLOCK();
i = VL_GetEntryByNameN(tconn->id, bp, &v->ntve);
RX_AFS_GLOCK();
if (i == RXGEN_OPCODE) {
type = 0;
tconn->srvr->server->flags |= SNO_LHOSTS;
RX_AFS_GUNLOCK();
i = VL_GetEntryByNameO(tconn->id, bp, &v->tve);
RX_AFS_GLOCK();
} else if (!i)
tconn->srvr->server->flags |= SYES_LHOSTS;
} else if (!i)
tconn->srvr->server->flags |= SVLSRV_UUID;
}
lastcode = i;
}
} else
i = -1;
} while (afs_Analyze(tconn, i, NULL, &treq, -1, /* no op code for this */
SHARED_LOCK, tcell));
afs_PutCell(tcell, READ_LOCK);
afs_Trace2(afs_iclSetp, CM_TRACE_CHECKVLDB, ICL_TYPE_FID, &afid,
ICL_TYPE_INT32, i);
if (i) {
afs_osi_Free(v, sizeof(*v));
return DUNNO;
}
/* have info, copy into serverHost array */
changed = 0;
tvp = afs_FindVolume(afid, WRITE_LOCK);
if (tvp) {
ObtainWriteLock(&tvp->lock, 107);
for (i = 0; i < NMAXNSERVERS && tvp->serverHost[i]; i++) {
oldhosts[i] = tvp->serverHost[i];
}
if (type == 2) {
InstallUVolumeEntry(tvp, &v->utve, afid->Cell, tcell, &treq);
} else if (type == 1) {
InstallNVolumeEntry(tvp, &v->ntve, afid->Cell);
} else {
InstallVolumeEntry(tvp, &v->tve, afid->Cell);
}
if (i < NMAXNSERVERS && tvp->serverHost[i]) {
changed = 1;
}
for (--i; !changed && i >= 0; i--) {
if (tvp->serverHost[i] != oldhosts[i]) {
changed = 1; /* also happens if prefs change. big deal. */
}
}
ReleaseWriteLock(&tvp->lock);
afs_PutVolume(tvp, WRITE_LOCK);
} else { /* can't find volume */
tvp = afs_GetVolume(afid, &treq, WRITE_LOCK);
if (tvp) {
afs_PutVolume(tvp, WRITE_LOCK);
afs_osi_Free(v, sizeof(*v));
return DIFFERENT;
} else {
afs_osi_Free(v, sizeof(*v));
return DUNNO;
}
}
afs_osi_Free(v, sizeof(*v));
return (changed ? DIFFERENT : SAME);
} /*VLDB_Same */
