/**
* 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;
}
/*!
* Return number of the primary cell.
* \return
* Cell number, or 0 if primary cell not found
*/
afs_int32
afs_GetPrimaryCellNum(void)
{
struct cell *cell;
afs_int32 cellNum = 0;
cell = afs_GetPrimaryCell(READ_LOCK);
if (cell) {
cellNum = cell->cellNum;
afs_PutCell(cell, READ_LOCK);
}
return cellNum;
}
int
SRXAFSCB_GetLocalCell(struct rx_call *a_call, char **a_name)
{
int plen;
struct cell *tcell;
char *t_name, *p_name = NULL;
RX_AFS_GLOCK();
AFS_STATCNT(SRXAFSCB_GetLocalCell);
/* Search the list for the primary cell. Cell number 1 is only
* the primary cell is when no other cell is explicitly marked as
* the primary cell. */
tcell = afs_GetPrimaryCell(READ_LOCK);
if (tcell)
p_name = tcell->cellName;
if (p_name)
plen = strlen(p_name);
else
plen = 0;
t_name = afs_osi_Alloc(plen + 1);
if (t_name == NULL) {
if (tcell)
afs_PutCell(tcell, READ_LOCK);
RX_AFS_GUNLOCK();
return ENOMEM;
}
t_name[plen] = '\0';
if (p_name)
memcpy(t_name, p_name, plen);
RX_AFS_GUNLOCK();
*a_name = t_name;
if (tcell)
afs_PutCell(tcell, READ_LOCK);
return 0;
}
/*!
* Returns afs_IsPrimaryCell(afs_GetCell(cellnum)).
* \param cellnum
* \return
*/
int
afs_IsPrimaryCellNum(afs_int32 cellnum)
{
struct cell *tc;
int primary = 0;
tc = afs_GetCellStale(cellnum, READ_LOCK);
if (tc) {
primary = afs_IsPrimaryCell(tc);
afs_PutCell(tc, READ_LOCK);
}
return primary;
}
int
SRXAFSCB_GetCellServDB(struct rx_call *a_call, afs_int32 a_index,
char **a_name, serverList * a_hosts)
{
afs_int32 i, j = 0;
struct cell *tcell;
char *t_name, *p_name = NULL;
RX_AFS_GLOCK();
AFS_STATCNT(SRXAFSCB_GetCellServDB);
tcell = afs_GetCellByIndex(a_index, READ_LOCK);
if (!tcell) {
i = 0;
a_hosts->serverList_val = 0;
a_hosts->serverList_len = 0;
} else {
p_name = tcell->cellName;
for (j = 0; j < AFSMAXCELLHOSTS && tcell->cellHosts[j]; j++);
i = strlen(p_name);
a_hosts->serverList_val = afs_osi_Alloc(j * sizeof(afs_int32));
osi_Assert(a_hosts->serverList_val != NULL);
a_hosts->serverList_len = j;
for (j = 0; j < AFSMAXCELLHOSTS && tcell->cellHosts[j]; j++)
a_hosts->serverList_val[j] =
ntohl(tcell->cellHosts[j]->addr->sa_ip);
afs_PutCell(tcell, READ_LOCK);
}
t_name = afs_osi_Alloc(i + 1);
if (t_name == NULL) {
afs_osi_Free(a_hosts->serverList_val, (j * sizeof(afs_int32)));
RX_AFS_GUNLOCK();
return ENOMEM;
}
t_name[i] = '\0';
if (p_name)
memcpy(t_name, p_name, i);
RX_AFS_GUNLOCK();
*a_name = t_name;
return 0;
}
/*!
* Check if the given name exists as a cell or alias. Does not lock afs_xcell.
* \param aname
* \return
*/
static int
afs_CellOrAliasExists_nl(char *aname)
{
struct cell *c;
struct cell_alias *ca;
c = afs_FindCellByName_nl(aname, READ_LOCK);
if (c) {
afs_PutCell(c, READ_LOCK);
return 1;
}
ca = afs_FindCellAlias(aname);
if (ca) {
afs_PutCellAlias(ca);
return 1;
}
return 0;
}
/*
* Set up a cell for dynroot if it's not there yet.
*/
static int
afs_dynrootCellInit(void)
{
if (!afs_dynrootCell) {
afs_int32 cellHosts[AFS_MAXCELLHOSTS];
struct cell *tc;
int code;
memset(cellHosts, 0, sizeof(cellHosts));
code =
afs_NewCell(AFS_DYNROOT_CELLNAME, cellHosts, CNoSUID | CNoAFSDB,
NULL, 0, 0, 0);
if (code)
return code;
tc = afs_GetCellByName(AFS_DYNROOT_CELLNAME, READ_LOCK);
if (!tc)
return ENODEV;
afs_dynrootCell = tc->cellNum;
afs_PutCell(tc, READ_LOCK);
}
return 0;
}
int
SRXAFSCB_GetCellByNum(struct rx_call *a_call, afs_int32 a_cellnum,
char **a_name, serverList * a_hosts)
{
afs_int32 i, sn;
struct cell *tcell;
RX_AFS_GLOCK();
AFS_STATCNT(SRXAFSCB_GetCellByNum);
a_hosts->serverList_val = 0;
a_hosts->serverList_len = 0;
tcell = afs_GetCellStale(a_cellnum, READ_LOCK);
if (!tcell) {
*a_name = afs_strdup("");
RX_AFS_GUNLOCK();
return 0;
}
ObtainReadLock(&tcell->lock);
*a_name = afs_strdup(tcell->cellName);
for (sn = 0; sn < AFSMAXCELLHOSTS && tcell->cellHosts[sn]; sn++);
a_hosts->serverList_len = sn;
a_hosts->serverList_val = afs_osi_Alloc(sn * sizeof(afs_int32));
osi_Assert(a_hosts->serverList_val != NULL);
for (i = 0; i < sn; i++)
a_hosts->serverList_val[i] = ntohl(tcell->cellHosts[i]->addr->sa_ip);
ReleaseReadLock(&tcell->lock);
afs_PutCell(tcell, READ_LOCK);
RX_AFS_GUNLOCK();
return 0;
}
/**
* @param aname Volume name.
* @param acell Cell id.
* @param agood
* @param areq Request type.
* @param locktype Type of lock to be used.
* @return Volume or NULL if failure.
*/
static struct volume *
afs_NewVolumeByName(char *aname, afs_int32 acell, int agood,
struct vrequest *areq, afs_int32 locktype)
{
afs_int32 code, type = 0;
struct volume *tv, *tv1;
struct vldbentry *tve;
struct nvldbentry *ntve;
struct uvldbentry *utve;
struct cell *tcell;
char *tbuffer, *ve;
struct afs_conn *tconn;
struct vrequest treq;
struct rx_connection *rxconn;
if (strlen(aname) > VL_MAXNAMELEN) /* Invalid volume name */
return NULL;
tcell = afs_GetCell(acell, READ_LOCK);
if (!tcell) {
return NULL;
}
/* allow null request if we don't care about ENODEV/ETIMEDOUT distinction */
if (!areq)
areq = &treq;
afs_Trace2(afs_iclSetp, CM_TRACE_GETVOL, ICL_TYPE_STRING, aname,
ICL_TYPE_POINTER, aname);
tbuffer = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
tve = (struct vldbentry *)(tbuffer + 1024);
ntve = (struct nvldbentry *)tve;
utve = (struct uvldbentry *)tve;
afs_InitReq(&treq, afs_osi_credp); /* *must* be unauth for vldb */
do {
tconn =
afs_ConnByMHosts(tcell->cellHosts, tcell->vlport, tcell->cellNum,
&treq, SHARED_LOCK, 0, &rxconn);
if (tconn) {
if (tconn->srvr->server->flags & SNO_LHOSTS) {
type = 0;
RX_AFS_GUNLOCK();
code = VL_GetEntryByNameO(rxconn, aname, tve);
RX_AFS_GLOCK();
} else if (tconn->srvr->server->flags & SYES_LHOSTS) {
type = 1;
RX_AFS_GUNLOCK();
code = VL_GetEntryByNameN(rxconn, aname, ntve);
RX_AFS_GLOCK();
} else {
type = 2;
RX_AFS_GUNLOCK();
code = VL_GetEntryByNameU(rxconn, aname, utve);
RX_AFS_GLOCK();
if (!(tconn->srvr->server->flags & SVLSRV_UUID)) {
if (code == RXGEN_OPCODE) {
type = 1;
RX_AFS_GUNLOCK();
code = VL_GetEntryByNameN(rxconn, aname, ntve);
RX_AFS_GLOCK();
if (code == RXGEN_OPCODE) {
type = 0;
tconn->srvr->server->flags |= SNO_LHOSTS;
RX_AFS_GUNLOCK();
code = VL_GetEntryByNameO(rxconn, aname, tve);
RX_AFS_GLOCK();
} else if (!code)
tconn->srvr->server->flags |= SYES_LHOSTS;
} else if (!code)
tconn->srvr->server->flags |= SVLSRV_UUID;
}
lastnvcode = code;
}
} else
code = -1;
} while (afs_Analyze(tconn, rxconn, code, NULL, &treq, -1, /* no op code for this */
SHARED_LOCK, tcell));
if (code) {
/* If the client has yet to contact this cell and contact failed due
* to network errors, mark the VLDB servers as back up.
* That the client tried and failed can be determined from the
* fact that there was a downtime incident, but CHasVolRef is not set.
*/
/* RT 48959 - unclear if this should really go */
#if 0
if (areq->networkError && !(tcell->states & CHasVolRef)) {
int i;
struct server *sp;
struct srvAddr *sap;
for (i = 0; i < AFS_MAXCELLHOSTS; i++) {
if ((sp = tcell->cellHosts[i]) == NULL)
break;
for (sap = sp->addr; sap; sap = sap->next_sa)
afs_MarkServerUpOrDown(sap, 0);
}
}
#endif
afs_CopyError(&treq, areq);
osi_FreeLargeSpace(tbuffer);
afs_PutCell(tcell, READ_LOCK);
return NULL;
}
/*
* Check to see if this cell has not yet referenced a volume. If
* it hasn't, it's just about to change its status, and we need to mark
* this fact down. Note that it is remotely possible that afs_SetupVolume
* could fail and we would still not have a volume reference.
*/
if (!(tcell->states & CHasVolRef)) {
tcell->states |= CHasVolRef;
afs_stats_cmperf.numCellsContacted++;
}
/*First time a volume in this cell has been referenced */
if (type == 2)
ve = (char *)utve;
else if (type == 1)
ve = (char *)ntve;
else
ve = (char *)tve;
tv = afs_SetupVolume(0, aname, ve, tcell, agood, type, &treq);
if ((agood == 3) && tv && tv->backVol) {
/*
* This means that very soon we'll ask for the BK volume so
* we'll prefetch it (well we did already.)
*/
tv1 =
afs_SetupVolume(tv->backVol, (char *)0, ve, tcell, 0, type, &treq);
if (tv1) {
tv1->refCount--;
}
}
if ((agood >= 2) && tv && tv->roVol) {
/*
* This means that very soon we'll ask for the RO volume so
* we'll prefetch it (well we did already.)
*/
tv1 = afs_SetupVolume(tv->roVol, NULL, ve, tcell, 0, type, &treq);
if (tv1) {
tv1->refCount--;
}
}
osi_FreeLargeSpace(tbuffer);
afs_PutCell(tcell, READ_LOCK);
return tv;
} /*afs_NewVolumeByName */
/*
* Regenerates the dynroot contents from the current list of
* cells. Useful when the list of cells has changed due to
* an AFSDB lookup, for instance.
*/
static void
afs_RebuildDynroot(void)
{
int cellidx, maxcellidx, i;
int aliasidx, maxaliasidx;
struct cell *c;
struct cell_alias *ca;
int curChunk, curPage;
int dirSize, dotLen;
char *newDir, *dotCell;
struct DirHeader *dirHeader;
int linkCount = 0;
struct afs_dynSymlink *ts;
int newVersion;
ObtainReadLock(&afs_dynrootDirLock);
newVersion = afs_dynrootVersion;
ReleaseReadLock(&afs_dynrootDirLock);
/*
* Compute the amount of space we need for the fake dir
*/
curChunk = 13;
curPage = 0;
/* Reserve space for "." and ".." */
curChunk += 2;
/* Reserve space for the dynamic-mount directory */
afs_dynroot_computeDirEnt(AFS_DYNROOT_MOUNTNAME, &curPage, &curChunk);
for (cellidx = 0;; cellidx++) {
c = afs_GetCellByIndex(cellidx, READ_LOCK);
if (!c)
break;
if (c->cellNum == afs_dynrootCell)
continue;
dotLen = strlen(c->cellName) + 2;
dotCell = afs_osi_Alloc(dotLen);
strcpy(dotCell, ".");
afs_strcat(dotCell, c->cellName);
afs_dynroot_computeDirEnt(c->cellName, &curPage, &curChunk);
afs_dynroot_computeDirEnt(dotCell, &curPage, &curChunk);
afs_osi_Free(dotCell, dotLen);
afs_PutCell(c, READ_LOCK);
}
maxcellidx = cellidx;
for (aliasidx = 0;; aliasidx++) {
ca = afs_GetCellAlias(aliasidx);
if (!ca)
break;
dotLen = strlen(ca->alias) + 2;
dotCell = afs_osi_Alloc(dotLen);
strcpy(dotCell, ".");
afs_strcat(dotCell, ca->alias);
afs_dynroot_computeDirEnt(ca->alias, &curPage, &curChunk);
afs_dynroot_computeDirEnt(dotCell, &curPage, &curChunk);
afs_osi_Free(dotCell, dotLen);
afs_PutCellAlias(ca);
}
maxaliasidx = aliasidx;
ObtainReadLock(&afs_dynSymlinkLock);
ts = afs_dynSymlinkBase;
while (ts) {
afs_dynroot_computeDirEnt(ts->name, &curPage, &curChunk);
ts = ts->next;
}
dirSize = (curPage + 1) * AFS_PAGESIZE;
newDir = afs_osi_Alloc(dirSize);
/*
* Now actually construct the directory.
*/
curChunk = 13;
curPage = 0;
dirHeader = (struct DirHeader *)newDir;
dirHeader->header.pgcount = 0;
dirHeader->header.tag = htons(1234);
dirHeader->header.freecount = 0;
dirHeader->header.freebitmap[0] = 0xff;
dirHeader->header.freebitmap[1] = 0x1f;
for (i = 2; i < EPP / 8; i++)
dirHeader->header.freebitmap[i] = 0;
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;
/* Install ".", "..", and the dynamic mount directory */
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, ".", 1);
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, "..", 1);
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk,
AFS_DYNROOT_MOUNTNAME, AFS_DYNROOT_MOUNT_VNODE);
linkCount += 3;
for (cellidx = 0; cellidx < maxcellidx; cellidx++) {
c = afs_GetCellByIndex(cellidx, READ_LOCK);
if (!c)
continue;
if (c->cellNum == afs_dynrootCell)
continue;
dotLen = strlen(c->cellName) + 2;
dotCell = afs_osi_Alloc(dotLen);
strcpy(dotCell, ".");
afs_strcat(dotCell, c->cellName);
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, c->cellName,
VNUM_FROM_CIDX_RW(cellidx, 0));
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, dotCell,
VNUM_FROM_CIDX_RW(cellidx, 1));
afs_osi_Free(dotCell, dotLen);
linkCount += 2;
afs_PutCell(c, READ_LOCK);
}
for (aliasidx = 0; aliasidx < maxaliasidx; aliasidx++) {
ca = afs_GetCellAlias(aliasidx);
if (!ca)
continue;
dotLen = strlen(ca->alias) + 2;
dotCell = afs_osi_Alloc(dotLen);
strcpy(dotCell, ".");
afs_strcat(dotCell, ca->alias);
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, ca->alias,
VNUM_FROM_CAIDX_RW(aliasidx, 0));
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, dotCell,
VNUM_FROM_CAIDX_RW(aliasidx, 1));
afs_osi_Free(dotCell, dotLen);
afs_PutCellAlias(ca);
}
ts = afs_dynSymlinkBase;
while (ts) {
int vnum = VNUM_FROM_TYPEID(VN_TYPE_SYMLINK, ts->index);
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, ts->name, vnum);
ts = ts->next;
}
ReleaseReadLock(&afs_dynSymlinkLock);
ObtainWriteLock(&afs_dynrootDirLock, 549);
if (afs_dynrootDir)
afs_osi_Free(afs_dynrootDir, afs_dynrootDirLen);
afs_dynrootDir = newDir;
afs_dynrootDirLen = dirSize;
afs_dynrootDirLinkcnt = linkCount;
afs_dynrootDirVersion = newVersion;
ReleaseWriteLock(&afs_dynrootDirLock);
}
/*
* 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;
}
int
afs_CheckRootVolume(void)
{
char rootVolName[32];
struct volume *tvp = NULL;
int usingDynroot = afs_GetDynrootEnable();
int localcell;
AFS_STATCNT(afs_CheckRootVolume);
if (*afs_rootVolumeName == 0) {
strcpy(rootVolName, "root.afs");
} else {
strcpy(rootVolName, afs_rootVolumeName);
}
if (usingDynroot) {
afs_GetDynrootFid(&afs_rootFid);
tvp = afs_GetVolume(&afs_rootFid, NULL, READ_LOCK);
} else {
struct cell *lc = afs_GetPrimaryCell(READ_LOCK);
if (!lc)
return ENOENT;
localcell = lc->cellNum;
afs_PutCell(lc, READ_LOCK);
tvp = afs_GetVolumeByName(rootVolName, localcell, 1, NULL, READ_LOCK);
if (!tvp) {
char buf[128];
int len = strlen(rootVolName);
if ((len < 9) || strcmp(&rootVolName[len - 9], ".readonly")) {
strcpy(buf, rootVolName);
afs_strcat(buf, ".readonly");
tvp = afs_GetVolumeByName(buf, localcell, 1, NULL, READ_LOCK);
}
}
if (tvp) {
int volid = (tvp->roVol ? tvp->roVol : tvp->volume);
afs_rootFid.Cell = localcell;
if (afs_rootFid.Fid.Volume && afs_rootFid.Fid.Volume != volid
&& afs_globalVp) {
/* If we had a root fid before and it changed location we reset
* the afs_globalVp so that it will be reevaluated.
* Just decrement the reference count. This only occurs during
* initial cell setup and can panic the machine if we set the
* count to zero and fs checkv is executed when the current
* directory is /afs.
*/
#ifdef AFS_LINUX20_ENV
{
struct vrequest *treq = NULL;
struct vattr vattr;
cred_t *credp;
struct dentry *dp;
struct vcache *vcp;
afs_rootFid.Fid.Volume = volid;
afs_rootFid.Fid.Vnode = 1;
afs_rootFid.Fid.Unique = 1;
credp = crref();
if (afs_CreateReq(&treq, credp))
goto out;
vcp = afs_GetVCache(&afs_rootFid, treq, NULL, NULL);
if (!vcp)
goto out;
afs_getattr(vcp, &vattr, credp);
afs_fill_inode(AFSTOV(vcp), &vattr);
dp = d_find_alias(AFSTOV(afs_globalVp));
#if defined(AFS_LINUX24_ENV)
#if defined(HAVE_DCACHE_LOCK)
spin_lock(&dcache_lock);
#else
spin_lock(&AFSTOV(vcp)->i_lock);
#endif
#if defined(AFS_LINUX26_ENV)
spin_lock(&dp->d_lock);
#endif
#endif
#if defined(D_ALIAS_IS_HLIST)
hlist_del_init(&dp->d_alias);
hlist_add_head(&dp->d_alias, &(AFSTOV(vcp)->i_dentry));
#else
list_del_init(&dp->d_alias);
list_add(&dp->d_alias, &(AFSTOV(vcp)->i_dentry));
#endif
dp->d_inode = AFSTOV(vcp);
#if defined(AFS_LINUX24_ENV)
#if defined(AFS_LINUX26_ENV)
spin_unlock(&dp->d_lock);
#endif
#if defined(HAVE_DCACHE_LOCK)
spin_unlock(&dcache_lock);
#else
spin_unlock(&AFSTOV(vcp)->i_lock);
#endif
#endif
dput(dp);
AFS_FAST_RELE(afs_globalVp);
afs_globalVp = vcp;
out:
crfree(credp);
afs_DestroyReq(treq);
}
#else
#ifdef AFS_DARWIN80_ENV
afs_PutVCache(afs_globalVp);
#else
AFS_FAST_RELE(afs_globalVp);
#endif
afs_globalVp = 0;
#endif
}
afs_rootFid.Fid.Volume = volid;
afs_rootFid.Fid.Vnode = 1;
afs_rootFid.Fid.Unique = 1;
}
}
if (tvp) {
afs_initState = 300; /* won */
afs_osi_Wakeup(&afs_initState);
afs_PutVolume(tvp, READ_LOCK);
}
if (afs_rootFid.Fid.Volume)
return 0;
else
return ENOENT;
}
/*!
* Create or update a cell entry.
* \param acellName Name of cell.
* \param acellHosts Array of hosts that this cell has.
* \param aflags Cell flags.
* \param linkedcname
* \param fsport File server port.
* \param vlport Volume server port.
* \param timeout Cell timeout value, 0 means static AFSDB entry.
* \return
*/
afs_int32
afs_NewCell(char *acellName, afs_int32 * acellHosts, int aflags,
char *linkedcname, u_short fsport, u_short vlport, int timeout)
{
struct cell *tc, *tcl = 0;
afs_int32 i, newc = 0, code = 0;
AFS_STATCNT(afs_NewCell);
ObtainWriteLock(&afs_xcell, 103);
tc = afs_FindCellByName_nl(acellName, READ_LOCK);
if (tc) {
aflags &= ~CNoSUID;
} else {
tc = afs_osi_Alloc(sizeof(struct cell));
osi_Assert(tc != NULL);
memset(tc, 0, sizeof(*tc));
tc->cellName = afs_strdup(acellName);
tc->fsport = AFS_FSPORT;
tc->vlport = AFS_VLPORT;
AFS_MD5_String(tc->cellHandle, tc->cellName, strlen(tc->cellName));
AFS_RWLOCK_INIT(&tc->lock, "cell lock");
newc = 1;
aflags |= CNoSUID;
}
ObtainWriteLock(&tc->lock, 688);
/* If the cell we've found has the correct name but no timeout,
* and we're called with a non-zero timeout, bail out: never
* override static configuration entries with AFSDB ones.
* One exception: if the original cell entry had no servers,
* it must get servers from AFSDB.
*/
if (timeout && !tc->timeout && tc->cellHosts[0]) {
code = EEXIST; /* This code is checked for in afs_LookupAFSDB */
goto bad;
}
/* we don't want to keep pinging old vlservers which were down,
* since they don't matter any more. It's easier to do this than
* to remove the server from its various hash tables. */
for (i = 0; i < AFS_MAXCELLHOSTS; i++) {
if (!tc->cellHosts[i])
break;
tc->cellHosts[i]->flags &= ~SRVR_ISDOWN;
tc->cellHosts[i]->flags |= SRVR_ISGONE;
}
if (fsport)
tc->fsport = fsport;
if (vlport)
tc->vlport = vlport;
if (aflags & CLinkedCell) {
if (!linkedcname) {
code = EINVAL;
goto bad;
}
tcl = afs_FindCellByName_nl(linkedcname, READ_LOCK);
if (!tcl) {
code = ENOENT;
goto bad;
}
if (tcl->lcellp) { /* XXX Overwriting if one existed before! XXX */
tcl->lcellp->lcellp = (struct cell *)0;
tcl->lcellp->states &= ~CLinkedCell;
}
tc->lcellp = tcl;
tcl->lcellp = tc;
}
tc->states |= aflags;
tc->timeout = timeout;
memset(tc->cellHosts, 0, sizeof(tc->cellHosts));
for (i = 0; i < AFS_MAXCELLHOSTS; i++) {
/* Get server for each host and link this cell in.*/
struct server *ts;
afs_uint32 temp = acellHosts[i];
if (!temp)
break;
ts = afs_GetServer(&temp, 1, 0, tc->vlport, WRITE_LOCK, NULL, 0);
ts->cell = tc;
ts->flags &= ~SRVR_ISGONE;
/* Set the server as a host of the new cell. */
tc->cellHosts[i] = ts;
afs_PutServer(ts, WRITE_LOCK);
}
afs_SortServers(tc->cellHosts, AFS_MAXCELLHOSTS); /* randomize servers */
/* New cell: Build and add to LRU cell queue. */
if (newc) {
struct cell_name *cn;
cn = afs_cellname_lookup_name(acellName);
if (!cn)
cn = afs_cellname_new(acellName, 0);
tc->cnamep = cn;
tc->cellNum = cn->cellnum;
tc->cellIndex = afs_cellindex++;
afs_stats_cmperf.numCellsVisible++;
QAdd(&CellLRU, &tc->lruq);
}
ReleaseWriteLock(&tc->lock);
ReleaseWriteLock(&afs_xcell);
afs_PutCell(tc, 0);
if (!(aflags & CHush))
afs_DynrootInvalidate();
return 0;
bad:
if (newc) {
afs_osi_FreeStr(tc->cellName);
afs_osi_Free(tc, sizeof(struct cell));
}
ReleaseWriteLock(&tc->lock);
ReleaseWriteLock(&afs_xcell);
return code;
}
static struct dentry *afs_decode_fh(struct super_block *sb, __u32 *fh,
int fh_len, int fh_type,
int (*acceptable)(void *, struct dentry *),
void *context)
#endif
{
struct VenusFid fid;
struct cell *tc;
struct dentry *result;
#if defined(NEW_EXPORT_OPS)
__u32 *fh = (__u32 *)fh_fid->raw;
#endif
switch (fh_type) {
case AFSFH_VENUSFID:
if (fh_len != 4)
return NULL;
fid.Cell = fh[0];
fid.Fid.Volume = fh[1];
fid.Fid.Vnode = fh[2];
fid.Fid.Unique = fh[3];
break;
case AFSFH_CELLFID:
if (fh_len != 7)
return NULL;
AFS_GLOCK();
tc = afs_GetCellByHandle((void *)fh, READ_LOCK);
if (!tc) {
AFS_GUNLOCK();
return NULL;
}
fid.Cell = tc->cellNum;
fid.Fid.Volume = fh[4];
fid.Fid.Vnode = fh[5];
fid.Fid.Unique = fh[6];
afs_PutCell(tc, READ_LOCK);
AFS_GUNLOCK();
break;
case AFSFH_NET_VENUSFID:
fid.Cell = ntohl(fh[0]);
fid.Fid.Volume = ntohl(fh[1]);
fid.Fid.Vnode = ntohl(fh[2]);
fid.Fid.Unique = ntohl(fh[3]);
break;
case AFSFH_NET_CELLFID:
if (fh_len != 7)
return NULL;
AFS_GLOCK();
tc = afs_GetCellByHandle((void *)fh, READ_LOCK);
if (!tc) {
AFS_GUNLOCK();
return NULL;
}
fid.Cell = tc->cellNum;
fid.Fid.Volume = ntohl(fh[4]);
fid.Fid.Vnode = ntohl(fh[5]);
fid.Fid.Unique = ntohl(fh[6]);
afs_PutCell(tc, READ_LOCK);
AFS_GUNLOCK();
break;
case AFSFH_DYN_RO_CELL:
case AFSFH_DYN_RW_CELL:
if (fh_len != 4)
return NULL;
AFS_GLOCK();
tc = afs_GetCellByHandle((void *)fh, READ_LOCK);
if (!tc) {
AFS_GUNLOCK();
return NULL;
}
afs_GetDynrootFid(&fid);
fid.Fid.Vnode = VNUM_FROM_CIDX_RW(tc->cellIndex, fh_type & 1);
fid.Fid.Unique = 1;
afs_PutCell(tc, READ_LOCK);
AFS_GUNLOCK();
break;
case AFSFH_DYN_RO_LINK:
case AFSFH_DYN_RW_LINK:
if (fh_len != 4)
return NULL;
AFS_GLOCK();
tc = afs_GetCellByHandle((void *)fh, READ_LOCK);
if (!tc) {
AFS_GUNLOCK();
return NULL;
}
afs_GetDynrootFid(&fid);
fid.Fid.Vnode = VNUM_FROM_CAIDX_RW(tc->cellIndex, fh_type & 1);
fid.Fid.Unique = 1;
afs_PutCell(tc, READ_LOCK);
AFS_GUNLOCK();
break;
case AFSFH_DYN_MOUNT:
if (fh_len != 5)
return NULL;
AFS_GLOCK();
tc = afs_GetCellByHandle((void *)fh, READ_LOCK);
if (!tc) {
AFS_GUNLOCK();
return NULL;
}
afs_GetDynrootFid(&fid);
fid.Fid.Vnode = VNUM_FROM_TYPEID(VN_TYPE_MOUNT,
tc->cellIndex << 2);
fid.Fid.Unique = ntohl(fh[4]);
afs_PutCell(tc, READ_LOCK);
AFS_GUNLOCK();
break;
case AFSFH_DYN_SYMLINK:
/* XXX parse dynroot symlink filehandle */
/* break; */
default:
return NULL;
}
#if defined(NEW_EXPORT_OPS)
result = afs_export_get_dentry(sb, &fid);
#else
result = sb->s_export_op->find_exported_dentry(sb, &fid, 0,
acceptable, context);
#endif
#ifdef OSI_EXPORT_DEBUG
if (!result) {
printk("afs: decode_fh(0x%08x/%d/%d.%d): no dentry\n",
fid.Cell, fid.Fid.Volume,
fid.Fid.Vnode, fid.Fid.Unique);
} else if (IS_ERR(result)) {
printk("afs: decode_fh(0x%08x/%d/%d.%d): error %ld\n",
fid.Cell, fid.Fid.Volume,
fid.Fid.Vnode, fid.Fid.Unique, PTR_ERR(result));
}
#endif
return result;
}
static int afs_encode_fh(struct dentry *de, __u32 *fh, int *max_len,
int connectable)
{
struct vcache *tvc;
struct cell *tc;
int vntype;
if (!de->d_inode) /* encode a negative dentry?! */
return 255;
if (*max_len < 4) /* not enough space */
return 255;
tvc = VTOAFS(de->d_inode);
#ifdef OSI_EXPORT_DEBUG
printk("afs: encode_fh(0x%08x/%d/%d.%d)\n",
tvc->f.fid.Cell, tvc->f.fid.Fid.Volume,
tvc->f.fid.Fid.Vnode, tvc->f.fid.Fid.Unique);
#endif
if (afs_IsDynrootAnyFid(&tvc->f.fid)) {
vntype = VNUM_TO_VNTYPE(tvc->f.fid.Fid.Vnode);
switch (vntype) {
case 0:
/* encode as a normal filehandle */
break;
case VN_TYPE_MOUNT:
if (*max_len < 5) {
return 255;
}
/* fall through */
case VN_TYPE_CELL:
case VN_TYPE_ALIAS:
AFS_GLOCK();
tc = afs_GetCellByIndex(VNUM_TO_CIDX(tvc->f.fid.Fid.Vnode),
READ_LOCK);
if (!tc) {
AFS_GUNLOCK();
return 255;
}
memcpy((void *)fh, tc->cellHandle, 16);
afs_PutCell(tc, READ_LOCK);
AFS_GUNLOCK();
if (vntype == VN_TYPE_MOUNT) {
fh[4] = htonl(tvc->f.fid.Fid.Unique);
*max_len = 5;
return AFSFH_DYN_MOUNT;
}
*max_len = 4;
if (vntype == VN_TYPE_CELL) {
return AFSFH_DYN_RO_CELL | VNUM_TO_RW(tvc->f.fid.Fid.Vnode);
} else {
return AFSFH_DYN_RO_LINK | VNUM_TO_RW(tvc->f.fid.Fid.Vnode);
}
case VN_TYPE_SYMLINK:
/* XXX fill in filehandle for dynroot symlink */
/* XXX return AFSFH_DYN_SYMLINK; */
default:
return 255;
}
}
if (*max_len < 7) {
/* not big enough for a migratable filehandle */
/* always encode in network order */
fh[0] = htonl(tvc->f.fid.Cell);
fh[1] = htonl(tvc->f.fid.Fid.Volume);
fh[2] = htonl(tvc->f.fid.Fid.Vnode);
fh[3] = htonl(tvc->f.fid.Fid.Unique);
*max_len = 4;
return AFSFH_NET_VENUSFID;
}
AFS_GLOCK();
tc = afs_GetCell(tvc->f.fid.Cell, READ_LOCK);
if (!tc) {
AFS_GUNLOCK();
return 255;
}
memcpy((void *)fh, tc->cellHandle, 16);
afs_PutCell(tc, READ_LOCK);
AFS_GUNLOCK();
/* always encode in network order */
fh[4] = htonl(tvc->f.fid.Fid.Volume);
fh[5] = htonl(tvc->f.fid.Fid.Vnode);
fh[6] = htonl(tvc->f.fid.Fid.Unique);
*max_len = 7;
return AFSFH_NET_CELLFID;
}
afs_fid(OSI_VC_DECL(avc), struct fid **fidpp)
#endif /* AFS_AIX41_ENV */
{
struct SmallFid Sfid;
long addr[2];
register struct cell *tcell;
extern struct vcache *afs_globalVp;
int SizeOfSmallFid = SIZEOF_SMALLFID;
int rootvp = 0;
OSI_VC_CONVERT(avc);
AFS_STATCNT(afs_fid);
if (afs_shuttingdown)
return EIO;
if (afs_NFSRootOnly && (avc == afs_globalVp))
rootvp = 1;
if (!afs_NFSRootOnly || rootvp
#ifdef AFS_AIX41_ENV
|| USE_SMALLFID(credp)
#endif
) {
tcell = afs_GetCell(avc->f.fid.Cell, READ_LOCK);
Sfid.Volume = avc->f.fid.Fid.Volume;
Sfid.Vnode = avc->f.fid.Fid.Vnode;
Sfid.CellAndUnique =
((tcell->cellIndex << 24) + (avc->f.fid.Fid.Unique & 0xffffff));
afs_PutCell(tcell, READ_LOCK);
if (avc->f.fid.Fid.Vnode > 0xffff)
afs_fid_vnodeoverflow++;
if (avc->f.fid.Fid.Unique > 0xffffff)
afs_fid_uniqueoverflow++;
} else {
#if defined(AFS_SUN57_64BIT_ENV) || (defined(AFS_SGI61_ENV) && (_MIPS_SZPTR == 64))
addr[1] = (long)AFS_XLATOR_MAGIC << 48;
#else /* defined(AFS_SGI61_ENV) && (_MIPS_SZPTR == 64) */
addr[1] = AFS_XLATOR_MAGIC;
SizeOfSmallFid = sizeof(addr);
#endif /* defined(AFS_SGI61_ENV) && (_MIPS_SZPTR == 64) */
addr[0] = (long)avc;
#ifndef AFS_AIX41_ENV
/* No post processing, so don't hold ref count. */
AFS_FAST_HOLD(avc);
#endif
}
#if defined(AFS_AIX_ENV) || defined(AFS_SUN54_ENV)
/* Use the fid pointer passed to us. */
fidpp->fid_len = SizeOfSmallFid;
if (afs_NFSRootOnly) {
if (rootvp
#ifdef AFS_AIX41_ENV
|| USE_SMALLFID(credp)
#endif
) {
memcpy(fidpp->fid_data, (caddr_t) & Sfid, SizeOfSmallFid);
} else {
memcpy(fidpp->fid_data, (caddr_t) addr, SizeOfSmallFid);
}
} else {
memcpy(fidpp->fid_data, (caddr_t) & Sfid, SizeOfSmallFid);
}
#else
/* malloc a fid pointer ourselves. */
*fidpp = (struct fid *)AFS_KALLOC(SizeOfSmallFid + 2);
(*fidpp)->fid_len = SizeOfSmallFid;
if (afs_NFSRootOnly) {
if (rootvp) {
memcpy((*fidpp)->fid_data, (char *)&Sfid, SizeOfSmallFid);
} else {
memcpy((*fidpp)->fid_data, (char *)addr, SizeOfSmallFid);
}
} else {
memcpy((*fidpp)->fid_data, (char *)&Sfid, SizeOfSmallFid);
}
#endif
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 */
static struct dentry *afs_export_get_parent(struct dentry *child)
{
struct VenusFid tfid;
struct vrequest treq;
struct cell *tcell;
struct vcache *vcp;
struct dentry *dp = NULL;
cred_t *credp;
afs_uint32 cellidx;
int code;
if (!child->d_inode) {
/* can't find the parent of a negative dentry */
#ifdef OSI_EXPORT_DEBUG
printk("afs: get_parent(%s): no inode\n",
child->d_name.name ? (char *)child->d_name.name : "?");
#endif
return ERR_PTR(-EIO);
}
credp = crref();
AFS_GLOCK();
vcp = VTOAFS(child->d_inode);
if (afs_IsDynrootMount(vcp)) {
/* the dynmount directory; parent is always the AFS root */
tfid = afs_globalVp->f.fid;
} else if (afs_IsDynrootAny(vcp) &&
VNUM_TO_VNTYPE(vcp->f.fid.Fid.Vnode) == VN_TYPE_MOUNT) {
/* a mount point in the dynmount directory */
afs_GetDynrootMountFid(&tfid);
} else if (vcp->mvstat == 2) {
/* volume root */
ObtainReadLock(&vcp->lock);
if (vcp->mvid && vcp->mvid->Fid.Volume) {
tfid = *vcp->mvid;
ReleaseReadLock(&vcp->lock);
} else {
ReleaseReadLock(&vcp->lock);
tcell = afs_GetCell(vcp->f.fid.Cell, READ_LOCK);
if (!tcell) {
#ifdef OSI_EXPORT_DEBUG
printk("afs: get_parent(0x%08x/%d/%d.%d): no cell\n",
vcp->f.fid.Cell, vcp->f.fid.Fid.Volume,
vcp->f.fid.Fid.Vnode, vcp->f.fid.Fid.Unique);
#endif
dp = ERR_PTR(-ENOENT);
goto done;
}
cellidx = tcell->cellIndex;
afs_PutCell(tcell, READ_LOCK);
afs_GetDynrootMountFid(&tfid);
tfid.Fid.Vnode = VNUM_FROM_TYPEID(VN_TYPE_MOUNT, cellidx << 2);
tfid.Fid.Unique = vcp->f.fid.Fid.Volume;
}
} else {
/* any other vnode */
if (vType(vcp) == VDIR && !vcp->f.parent.vnode && vcp->mvstat != 1) {
code = afs_InitReq(&treq, credp);
if (code) {
#ifdef OSI_EXPORT_DEBUG
printk("afs: get_parent(0x%08x/%d/%d.%d): InitReq: %d\n",
vcp->f.fid.Cell, vcp->f.fid.Fid.Volume,
vcp->f.fid.Fid.Vnode, vcp->f.fid.Fid.Unique, code);
#endif
dp = ERR_PTR(-ENOENT);
goto done;
} else {
code = update_dir_parent(&treq, vcp);
if (code) {
#ifdef OSI_EXPORT_DEBUG
printk("afs: get_parent(0x%08x/%d/%d.%d): update_dir_parent: %d\n",
vcp->f.fid.Cell, vcp->f.fid.Fid.Volume,
vcp->f.fid.Fid.Vnode, vcp->f.fid.Fid.Unique, code);
#endif
dp = ERR_PTR(-ENOENT);
goto done;
}
}
}
tfid.Cell = vcp->f.fid.Cell;
tfid.Fid.Volume = vcp->f.fid.Fid.Volume;
tfid.Fid.Vnode = vcp->f.parent.vnode;
tfid.Fid.Unique = vcp->f.parent.unique;
}
#ifdef OSI_EXPORT_DEBUG
printk("afs: get_parent(0x%08x/%d/%d.%d): => 0x%08x/%d/%d.%d\n",
vcp->f.fid.Cell, vcp->f.fid.Fid.Volume,
vcp->f.fid.Fid.Vnode, vcp->f.fid.Fid.Unique,
tfid.Cell, tfid.Fid.Volume, tfid.Fid.Vnode, tfid.Fid.Unique);
#endif
dp = get_dentry_from_fid(credp, &tfid);
if (!dp) {
#ifdef OSI_EXPORT_DEBUG
printk("afs: get_parent(0x%08x/%d/%d.%d): no dentry\n",
vcp->f.fid.Cell, vcp->f.fid.Fid.Volume,
vcp->f.fid.Fid.Vnode, vcp->f.fid.Fid.Unique);
#endif
dp = ERR_PTR(-ENOENT);
}
done:
AFS_GUNLOCK();
crfree(credp);
return dp;
}