/*!
* Generate a fake fid (vnode and uniquifier) for a vcache
* (either dir or normal file). The vnode is generated via
* afs_DisconVNode and the uniquifier by getting the highest
* uniquifier on a hash chain and incrementing it by one.
*
* \param afid The fid structre that will be filled.
* \param avtype Vnode type: VDIR/VREG.
* \param lock True indicates that xvcache may be obtained,
* False that it is already held
*
* \note The cell number must be completed somewhere else.
*/
void
afs_GenFakeFid(struct VenusFid *afid, afs_uint32 avtype, int lock)
{
struct vcache *tvc;
afs_uint32 max_unique = 0, i;
switch (avtype) {
case VDIR:
afid->Fid.Vnode = afs_DisconVnode + 1;
break;
case VREG:
case VLNK:
afid->Fid.Vnode = afs_DisconVnode;
break;
}
if (lock)
ObtainWriteLock(&afs_xvcache, 736);
i = VCHash(afid);
for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
if (tvc->f.fid.Fid.Unique > max_unique)
max_unique = tvc->f.fid.Fid.Unique;
}
if (lock)
ReleaseWriteLock(&afs_xvcache);
afid->Fid.Unique = max_unique + 1;
afs_DisconVnode += 2;
if (!afs_DisconVnode)
afs_DisconVnode = 2;
}
/*!
* Handles all the reconnection details:
* - Get all the details about the vnode: name, fid, and parent dir fid.
* - Send data to server.
* - Handle errors.
* - Reorder vhash and dcaches in their hashes, using the newly acquired fid.
*/
int
afs_ProcessOpCreate(struct vcache *avc, struct vrequest *areq,
afs_ucred_t *acred)
{
char *tname = NULL, *ttargetName = NULL;
struct AFSStoreStatus InStatus;
struct AFSFetchStatus OutFidStatus, OutDirStatus;
struct VenusFid pdir_fid, newFid;
struct AFSCallBack CallBack;
struct AFSVolSync tsync;
struct vcache *tdp = NULL, *tvc = NULL;
struct dcache *tdc = NULL;
struct afs_conn *tc;
struct rx_connection *rxconn;
afs_int32 hash, new_hash, index;
afs_size_t tlen;
int code, op = 0;
XSTATS_DECLS;
tname = afs_osi_Alloc(AFSNAMEMAX);
if (!tname)
return ENOMEM;
code = afs_GetParentVCache(avc, 0, &pdir_fid, tname, &tdp);
if (code)
goto end;
/* This data may also be in linkData, but then we have to deal with
* the joy of terminating NULLs and . and file modes. So just get
* it from the dcache where it won't have been fiddled with.
*/
if (vType(avc) == VLNK) {
afs_size_t offset;
struct dcache *tdc;
struct osi_file *tfile;
tdc = afs_GetDCache(avc, 0, areq, &offset, &tlen, 0);
if (!tdc) {
code = ENOENT;
goto end;
}
if (tlen > 1024) {
afs_PutDCache(tdc);
code = EFAULT;
goto end;
}
tlen++; /* space for NULL */
ttargetName = afs_osi_Alloc(tlen);
if (!ttargetName) {
afs_PutDCache(tdc);
return ENOMEM;
}
ObtainReadLock(&tdc->lock);
tfile = afs_CFileOpen(&tdc->f.inode);
code = afs_CFileRead(tfile, 0, ttargetName, tlen);
ttargetName[tlen-1] = '\0';
afs_CFileClose(tfile);
ReleaseReadLock(&tdc->lock);
afs_PutDCache(tdc);
}
/* Set status. */
InStatus.Mask = AFS_SETMODTIME | AFS_SETMODE | AFS_SETGROUP;
InStatus.ClientModTime = avc->f.m.Date;
InStatus.Owner = avc->f.m.Owner;
InStatus.Group = (afs_int32) afs_cr_gid(acred);
/* Only care about protection bits. */
InStatus.UnixModeBits = avc->f.m.Mode & 0xffff;
do {
tc = afs_Conn(&tdp->f.fid, areq, SHARED_LOCK, &rxconn);
if (tc) {
switch (vType(avc)) {
case VREG:
/* Make file on server. */
op = AFS_STATS_FS_RPCIDX_CREATEFILE;
XSTATS_START_TIME(op);
RX_AFS_GUNLOCK();
code = RXAFS_CreateFile(tc->id,
(struct AFSFid *)&tdp->f.fid.Fid,
tname, &InStatus,
(struct AFSFid *) &newFid.Fid,
&OutFidStatus, &OutDirStatus,
&CallBack, &tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
break;
case VDIR:
/* Make dir on server. */
op = AFS_STATS_FS_RPCIDX_MAKEDIR;
XSTATS_START_TIME(op);
RX_AFS_GUNLOCK();
code = RXAFS_MakeDir(rxconn, (struct AFSFid *) &tdp->f.fid.Fid,
tname, &InStatus,
(struct AFSFid *) &newFid.Fid,
&OutFidStatus, &OutDirStatus,
&CallBack, &tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
break;
case VLNK:
/* Make symlink on server. */
op = AFS_STATS_FS_RPCIDX_SYMLINK;
XSTATS_START_TIME(op);
RX_AFS_GUNLOCK();
code = RXAFS_Symlink(rxconn,
(struct AFSFid *) &tdp->f.fid.Fid,
tname, ttargetName, &InStatus,
(struct AFSFid *) &newFid.Fid,
&OutFidStatus, &OutDirStatus, &tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
break;
default:
op = AFS_STATS_FS_RPCIDX_CREATEFILE;
code = 1;
break;
}
} else
code = -1;
} while (afs_Analyze(tc, rxconn, code, &tdp->f.fid, areq, op, SHARED_LOCK, NULL));
/* TODO: Handle errors. */
if (code) {
/* printf("afs_ProcessOpCreate: error while creating vnode on server, code=%d .\n", code); */
goto end;
}
/* The rpc doesn't set the cell number. */
newFid.Cell = avc->f.fid.Cell;
/*
* Change the fid in the dir entry.
*/
/* Seek the dir's dcache. */
tdc = afs_FindDCacheByFid(&tdp->f.fid);
if (tdc) {
/* And now change the fid in the parent dir entry. */
afs_dir_ChangeFid(tdc, tname, &avc->f.fid.Fid.Vnode, &newFid.Fid.Vnode);
afs_PutDCache(tdc);
}
if (vType(avc) == VDIR) {
/* Change fid in the dir for the "." entry. ".." has alredy been
* handled by afs_FixChildrenFids when processing the parent dir.
*/
tdc = afs_FindDCacheByFid(&avc->f.fid);
if (tdc) {
afs_dir_ChangeFid(tdc, ".", &avc->f.fid.Fid.Vnode,
&newFid.Fid.Vnode);
if (avc->f.m.LinkCount >= 2)
/* For non empty dirs, fix children's parentVnode and
* parentUnique reference.
*/
afs_FixChildrenFids(&avc->f.fid, &newFid);
afs_PutDCache(tdc);
}
}
/* Recompute hash chain positions for vnode and dcaches.
* Then change to the new FID.
*/
/* The vcache goes first. */
ObtainWriteLock(&afs_xvcache, 735);
/* Old fid hash. */
hash = VCHash(&avc->f.fid);
/* New fid hash. */
new_hash = VCHash(&newFid);
/* Remove hash from old position. */
/* XXX: not checking array element contents. It shouldn't be empty.
* If it oopses, then something else might be wrong.
*/
if (afs_vhashT[hash] == avc) {
/* First in hash chain (might be the only one). */
afs_vhashT[hash] = avc->hnext;
} else {
/* More elements in hash chain. */
for (tvc = afs_vhashT[hash]; tvc; tvc = tvc->hnext) {
if (tvc->hnext == avc) {
tvc->hnext = avc->hnext;
break;
}
}
} /* if (!afs_vhashT[i]->hnext) */
QRemove(&avc->vhashq);
/* Insert hash in new position. */
avc->hnext = afs_vhashT[new_hash];
afs_vhashT[new_hash] = avc;
QAdd(&afs_vhashTV[VCHashV(&newFid)], &avc->vhashq);
ReleaseWriteLock(&afs_xvcache);
/* Do the same thing for all dcaches. */
hash = DVHash(&avc->f.fid);
ObtainWriteLock(&afs_xdcache, 743);
for (index = afs_dvhashTbl[hash]; index != NULLIDX; index = hash) {
hash = afs_dvnextTbl[index];
tdc = afs_GetValidDSlot(index);
ReleaseReadLock(&tdc->tlock);
if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
if (!FidCmp(&tdc->f.fid, &avc->f.fid)) {
/* Safer but slower. */
afs_HashOutDCache(tdc, 0);
/* Put dcache in new positions in the dchash and dvhash. */
new_hash = DCHash(&newFid, tdc->f.chunk);
afs_dcnextTbl[tdc->index] = afs_dchashTbl[new_hash];
afs_dchashTbl[new_hash] = tdc->index;
new_hash = DVHash(&newFid);
afs_dvnextTbl[tdc->index] = afs_dvhashTbl[new_hash];
afs_dvhashTbl[new_hash] = tdc->index;
afs_indexUnique[tdc->index] = newFid.Fid.Unique;
memcpy(&tdc->f.fid, &newFid, sizeof(struct VenusFid));
} /* if fid match */
} /* if uniquifier match */
if (tdc)
afs_PutDCache(tdc);
} /* for all dcaches in this hash bucket */
ReleaseWriteLock(&afs_xdcache);
/* Now we can set the new fid. */
memcpy(&avc->f.fid, &newFid, sizeof(struct VenusFid));
end:
if (tdp)
afs_PutVCache(tdp);
afs_osi_Free(tname, AFSNAMEMAX);
if (ttargetName)
afs_osi_Free(ttargetName, tlen);
return code;
}
static int
ClearCallBack(struct rx_connection *a_conn,
struct AFSFid *a_fid)
{
struct vcache *tvc;
int i;
struct VenusFid localFid;
struct volume *tv;
#ifdef AFS_DARWIN80_ENV
vnode_t vp;
#endif
AFS_STATCNT(ClearCallBack);
AFS_ASSERT_GLOCK();
/*
* XXXX Don't hold any server locks here because of callback protocol XXX
*/
localFid.Cell = 0;
localFid.Fid.Volume = a_fid->Volume;
localFid.Fid.Vnode = a_fid->Vnode;
localFid.Fid.Unique = a_fid->Unique;
/*
* Volume ID of zero means don't do anything.
*/
if (a_fid->Volume != 0) {
if (a_fid->Vnode == 0) {
struct afs_q *tq, *uq;
/*
* Clear callback for the whole volume. Zip through the
* hash chain, nullifying entries whose volume ID matches.
*/
loop1:
ObtainReadLock(&afs_xvcache);
i = VCHashV(&localFid);
for (tq = afs_vhashTV[i].prev; tq != &afs_vhashTV[i]; tq = uq) {
uq = QPrev(tq);
tvc = QTOVH(tq);
if (tvc->f.fid.Fid.Volume == a_fid->Volume) {
tvc->callback = NULL;
if (!localFid.Cell)
localFid.Cell = tvc->f.fid.Cell;
tvc->dchint = NULL; /* invalidate hints */
if (tvc->f.states & CVInit) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop1;
}
#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV)
AFS_FAST_HOLD(tvc);
#else
#ifdef AFS_DARWIN80_ENV
if (tvc->f.states & CDeadVnode) {
if (!(tvc->f.states & CBulkFetching)) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop1;
}
}
vp = AFSTOV(tvc);
if (vnode_get(vp))
continue;
if (vnode_ref(vp)) {
AFS_GUNLOCK();
vnode_put(vp);
AFS_GLOCK();
continue;
}
if (tvc->f.states & (CBulkFetching|CDeadVnode)) {
AFS_GUNLOCK();
vnode_recycle(AFSTOV(tvc));
AFS_GLOCK();
}
#else
AFS_FAST_HOLD(tvc);
#endif
#endif
ReleaseReadLock(&afs_xvcache);
ObtainWriteLock(&afs_xcbhash, 449);
afs_DequeueCallback(tvc);
tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
afs_allCBs++;
if (tvc->f.fid.Fid.Vnode & 1)
afs_oddCBs++;
else
afs_evenCBs++;
ReleaseWriteLock(&afs_xcbhash);
if ((tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR)))
osi_dnlc_purgedp(tvc);
afs_Trace3(afs_iclSetp, CM_TRACE_CALLBACK,
ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32,
tvc->f.states, ICL_TYPE_INT32,
a_fid->Volume);
#ifdef AFS_DARWIN80_ENV
vnode_put(AFSTOV(tvc));
#endif
ObtainReadLock(&afs_xvcache);
uq = QPrev(tq);
AFS_FAST_RELE(tvc);
} else if ((tvc->f.states & CMValid)
&& (tvc->mvid->Fid.Volume == a_fid->Volume)) {
tvc->f.states &= ~CMValid;
if (!localFid.Cell)
localFid.Cell = tvc->mvid->Cell;
}
}
ReleaseReadLock(&afs_xvcache);
/*
* XXXX Don't hold any locks here XXXX
*/
tv = afs_FindVolume(&localFid, 0);
if (tv) {
afs_ResetVolumeInfo(tv);
afs_PutVolume(tv, 0);
/* invalidate mtpoint? */
}
} /*Clear callbacks for whole volume */
else {
/*
* Clear callbacks just for the one file.
*/
struct vcache *uvc;
afs_allCBs++;
if (a_fid->Vnode & 1)
afs_oddCBs++; /*Could do this on volume basis, too */
else
afs_evenCBs++; /*A particular fid was specified */
loop2:
ObtainReadLock(&afs_xvcache);
i = VCHash(&localFid);
for (tvc = afs_vhashT[i]; tvc; tvc = uvc) {
uvc = tvc->hnext;
if (tvc->f.fid.Fid.Vnode == a_fid->Vnode
&& tvc->f.fid.Fid.Volume == a_fid->Volume
&& tvc->f.fid.Fid.Unique == a_fid->Unique) {
tvc->callback = NULL;
tvc->dchint = NULL; /* invalidate hints */
if (tvc->f.states & CVInit) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop2;
}
#if defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX20_ENV)
AFS_FAST_HOLD(tvc);
#else
#ifdef AFS_DARWIN80_ENV
if (tvc->f.states & CDeadVnode) {
if (!(tvc->f.states & CBulkFetching)) {
ReleaseReadLock(&afs_xvcache);
afs_osi_Sleep(&tvc->f.states);
goto loop2;
}
}
vp = AFSTOV(tvc);
if (vnode_get(vp))
continue;
if (vnode_ref(vp)) {
AFS_GUNLOCK();
vnode_put(vp);
AFS_GLOCK();
continue;
}
if (tvc->f.states & (CBulkFetching|CDeadVnode)) {
AFS_GUNLOCK();
vnode_recycle(AFSTOV(tvc));
AFS_GLOCK();
}
#else
AFS_FAST_HOLD(tvc);
#endif
#endif
ReleaseReadLock(&afs_xvcache);
ObtainWriteLock(&afs_xcbhash, 450);
afs_DequeueCallback(tvc);
tvc->f.states &= ~(CStatd | CUnique | CBulkFetching);
ReleaseWriteLock(&afs_xcbhash);
if ((tvc->f.fid.Fid.Vnode & 1 || (vType(tvc) == VDIR)))
osi_dnlc_purgedp(tvc);
afs_Trace3(afs_iclSetp, CM_TRACE_CALLBACK,
ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32,
tvc->f.states, ICL_TYPE_LONG, 0);
#ifdef CBDEBUG
lastCallBack_vnode = afid->Vnode;
lastCallBack_dv = tvc->mstat.DataVersion.low;
osi_GetuTime(&lastCallBack_time);
#endif /* CBDEBUG */
#ifdef AFS_DARWIN80_ENV
vnode_put(AFSTOV(tvc));
#endif
ObtainReadLock(&afs_xvcache);
uvc = tvc->hnext;
AFS_FAST_RELE(tvc);
}
} /*Walk through hash table */
ReleaseReadLock(&afs_xvcache);
} /*Clear callbacks for one file */
}
/*Fid has non-zero volume ID */
/*
* Always return a predictable value.
*/
return (0);
} /*ClearCallBack */