cm_SetFid(&cm_data.rootFid, cm_data.rootCellp->cellID, cm_GetROVolumeID(cm_data.rootVolumep), 1, 1);
}
- code = cm_GetSCache(&cm_data.rootFid, &cm_data.rootSCachep, cm_rootUserp, &req);
+ code = cm_GetSCache(&cm_data.rootFid, NULL, &cm_data.rootSCachep, cm_rootUserp, &req);
afsi_log("cm_GetSCache code %x scache %x", code,
(code ? (cm_scache_t *)-1 : cm_data.rootSCachep));
if (code != 0) {
/* not a dir, use parent dir's acl */
cm_SetFid(&tfid, scp->fid.cell, scp->fid.volume, scp->parentVnode, scp->parentUnique);
lock_ReleaseWrite(&scp->rw);
- code = cm_GetSCache(&tfid, &aclScp, userp, reqp);
+ code = cm_GetSCache(&tfid, NULL, &aclScp, userp, reqp);
if (code) {
lock_ObtainWrite(&scp->rw);
goto _done;
* that the cm_scache_t was recycled out of the cache even though
* a cm_buf_t with the same FID is in the cache.
*/
- if (scp == NULL) {
- if ((scp = cm_FindSCache(&bp->fid)) ||
- (cm_GetSCache(&bp->fid, &scp,
- bp->userp ? bp->userp : cm_rootUserp,
- reqp) == 0)) {
- release_scp = 1;
- }
+ if (scp == NULL &&
+ cm_GetSCache(&bp->fid, NULL, &scp,
+ bp->userp ? bp->userp : cm_rootUserp,
+ reqp) == 0)
+ {
+ release_scp = 1;
}
while ((bp->flags & CM_BUF_DIRTY) == CM_BUF_DIRTY) {
}
#ifdef DEBUG_REFCOUNT
-long cm_GetSCacheDbg(cm_fid_t *fidp, cm_scache_t **outScpp, cm_user_t *userp,
+long cm_GetSCacheDbg(cm_fid_t *fidp, cm_fid_t *parentFidp, cm_scache_t **outScpp, cm_user_t *userp,
cm_req_t *reqp, char * file, long line)
#else
-long cm_GetSCache(cm_fid_t *fidp, cm_scache_t **outScpp, cm_user_t *userp,
+long cm_GetSCache(cm_fid_t *fidp, cm_fid_t *parentFidp, cm_scache_t **outScpp, cm_user_t *userp,
cm_req_t *reqp)
#endif
{
cm_data.fakeDirVersion != scp->dataVersion)
break;
#endif
+ if (parentFidp && scp->parentVnode == 0) {
+ scp->parentVnode = parentFidp->vnode;
+ scp->parentUnique = parentFidp->unique;
+ }
cm_HoldSCacheNoLock(scp);
*outScpp = scp;
lock_ConvertRToW(&cm_scacheLock);
lock_ObtainWrite(&scp->rw);
}
scp->fid = *fidp;
- scp->dotdotFid.cell=AFS_FAKE_ROOT_CELL_ID;
- scp->dotdotFid.volume=AFS_FAKE_ROOT_VOL_ID;
- scp->dotdotFid.unique=1;
- scp->dotdotFid.vnode=1;
+ cm_SetFid(&scp->dotdotFid,AFS_FAKE_ROOT_CELL_ID,AFS_FAKE_ROOT_VOL_ID,1,1);
+ if (parentFidp) {
+ scp->parentVnode = parentFidp->vnode;
+ scp->parentUnique = parentFidp->unique;
+ }
_InterlockedOr(&scp->flags, (CM_SCACHEFLAG_PURERO | CM_SCACHEFLAG_RO));
lock_ObtainWrite(&cm_scacheLock);
if (!(scp->flags & CM_SCACHEFLAG_INHASH)) {
afsi_log("%s:%d cm_GetSCache (3) scp 0x%p ref %d", file, line, scp, scp->refCount);
osi_Log1(afsd_logp,"cm_GetSCache (3) scp 0x%p", scp);
#endif
+ if (parentFidp && scp->parentVnode == 0) {
+ scp->parentVnode = parentFidp->vnode;
+ scp->parentUnique = parentFidp->unique;
+ }
if (volp)
cm_PutVolume(volp);
cm_HoldSCacheNoLock(scp);
scp->fid = *fidp;
if (!cm_freelanceEnabled || !isRoot) {
/* if this scache entry represents a volume root then we need
- * to copy the dotdotFipd from the volume structure where the
+ * to copy the dotdotFid from the volume structure where the
* "master" copy is stored (defect 11489)
*/
if (volp->vol[ROVOL].ID == fidp->volume) {
scp->dotdotFid = cm_VolumeStateByType(volp, RWVOL)->dotdotFid;
}
}
+ if (parentFidp) {
+ scp->parentVnode = parentFidp->vnode;
+ scp->parentUnique = parentFidp->unique;
+ }
if (volp)
cm_PutVolume(volp);
cm_fid_t parent_fid;
cm_scache_t * pscp = NULL;
+ if (scp->parentVnode == 0)
+ return NULL;
+
lock_ObtainWrite(&cm_scacheLock);
cm_SetFid(&parent_fid, scp->fid.cell, scp->fid.volume, scp->parentVnode, scp->parentUnique);
extern void cm_InitSCache(int, long);
#ifdef DEBUG_REFCOUNT
-extern long cm_GetSCacheDbg(cm_fid_t *, cm_scache_t **, struct cm_user *,
+extern long cm_GetSCacheDbg(cm_fid_t *, cm_fid_t *, cm_scache_t **, struct cm_user *,
struct cm_req *, char *, long);
#define cm_GetSCache(a,b,c,d) cm_GetSCacheDbg(a,b,c,d,__FILE__,__LINE__)
#else
-extern long cm_GetSCache(cm_fid_t *, cm_scache_t **, struct cm_user *,
+extern long cm_GetSCache(cm_fid_t *, cm_fid_t *, cm_scache_t **, struct cm_user *,
struct cm_req *);
#endif
if (scp->mountRootFid.cell != 0 && scp->mountRootGen >= cm_data.mountRootGen) {
tfid = scp->mountRootFid;
lock_ReleaseWrite(&scp->rw);
- code = cm_GetSCache(&tfid, outScpp, userp, reqp);
+ code = cm_GetSCache(&tfid, NULL, outScpp, userp, reqp);
lock_ObtainWrite(&scp->rw);
return code;
}
tfid = scp->mountRootFid;
lock_ReleaseWrite(&scp->rw);
- code = cm_GetSCache(&tfid, outScpp, userp, reqp);
+ code = cm_GetSCache(&tfid, NULL, outScpp, userp, reqp);
lock_ObtainWrite(&scp->rw);
}
if ( !tscp ) /* we did not find it in the dnlc */
{
dnlcHit = 0;
- code = cm_GetSCache(&rock.fid, &tscp, userp, reqp);
+ code = cm_GetSCache(&rock.fid, &dscp->fid, &tscp, userp, reqp);
if (code)
goto done;
}
cm_SetFid(&fid, cellp->cellID, volume, 1, 1);
- code = cm_GetSCache(&fid, outScpp, userp, reqp);
+ code = cm_GetSCache(&fid, NULL, outScpp, userp, reqp);
_exit_cleanup:
if (fnamep)
!(tfid.vnode==0x1 && tfid.unique==0x1) )
{
osi_Log0(afsd_logp, "cm_TryBulkProc Freelance calls cm_SCache on root.afs mountpoint");
- return cm_GetSCache(&tfid, &tscp, NULL, NULL);
+ return cm_GetSCache(&tfid, NULL, &tscp, NULL, NULL);
}
#endif /* AFS_FREELANCE_CLIENT */
cm_req_t treq = *reqp;
cm_Analyze(NULL, userp, &treq, &tfid, 0, &volSync, NULL, &cbReq, (&bbp->stats[j])->errorCode);
} else {
- code = cm_GetSCache(&tfid, &scp, userp, reqp);
+ code = cm_GetSCache(&tfid, &dscp->fid, &scp, userp, reqp);
if (code != 0)
continue;
* info.
*/
if (code == 0) {
- code = cm_GetSCache(&newFid, &scp, userp, reqp);
+ code = cm_GetSCache(&newFid, &dscp->fid, &scp, userp, reqp);
if (code == 0) {
lock_ObtainWrite(&scp->rw);
scp->creator = userp; /* remember who created it */
* info.
*/
if (code == 0) {
- code = cm_GetSCache(&newFid, &scp, userp, reqp);
+ code = cm_GetSCache(&newFid, &dscp->fid, &scp, userp, reqp);
if (code == 0) {
lock_ObtainWrite(&scp->rw);
if (!cm_HaveCallback(scp)) {
* info.
*/
if (code == 0) {
- code = cm_GetSCache(&newFid, &scp, userp, reqp);
+ code = cm_GetSCache(&newFid, &dscp->fid, &scp, userp, reqp);
if (code == 0) {
lock_ObtainWrite(&scp->rw);
if (!cm_HaveCallback(scp)) {
cm_InitReq(&req);
lock_ReleaseRead(&cm_volumeLock);
- if (cm_GetSCache(&fid, &scp, cm_rootUserp, &req) == 0) {
+ if (cm_GetSCache(&fid, NULL, &scp, cm_rootUserp, &req) == 0) {
lock_ObtainWrite(&scp->rw);
cm_GetCallback(scp, cm_rootUserp, &req, 1);
lock_ReleaseWrite(&scp->rw);
continue;
}
- cm_GetSCache(&entryp->fid, &scp, userp, &req);
+ cm_GetSCache(&entryp->fid, NULL, &scp, userp, &req);
switch (InfoStruct->Level) {
case 2:
reqp->relPathp = path;
reqp->tidPathp = tidPathp;
- code = cm_GetSCache(&patchp->fid, &scp, userp, reqp);
+ code = cm_GetSCache(&patchp->fid, &dscp->fid, &scp, userp, reqp);
reqp->relPathp = reqp->tidPathp = NULL;
if (code) {
if (patchp->flags & SMB_DIRLISTPATCH_IOCTL)
continue;
- code = cm_GetSCache(&patchp->fid, &tscp, userp, reqp);
+ code = cm_GetSCache(&patchp->fid, &dscp->fid, &tscp, userp, reqp);
if (code == 0) {
if (lock_TryWrite(&tscp->rw)) {
/* we have an entry that we can look at */
continue;
}
- code = cm_GetSCache(&patchp->fid, &scp, userp, reqp);
+ code = cm_GetSCache(&patchp->fid, &dscp->fid, &scp, userp, reqp);
reqp->relPathp = reqp->tidPathp = NULL;
if (code)
continue;
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = smb_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
fid.unique = DirID.Unique;
fid.hash = DirID.Hash;
- code = cm_GetSCache(&fid, &dscp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &dscp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
}
if (bSkipStatus) {
- code = cm_GetSCache(&entryp->fid, &scp, userp, &req);
+ code = cm_GetSCache(&entryp->fid, &dscp->fid, &scp, userp, &req);
if (code) {
osi_Log5(afsd_logp, "RDR_EnumerateDirectory cm_GetSCache failure cell %u vol %u vnode %u uniq %u code=0x%x",
entryp->fid.cell, entryp->fid.volume, entryp->fid.vnode, entryp->fid.unique, code);
parentFid.unique = ParentID.Unique;
parentFid.hash = ParentID.Hash;
- code = cm_GetSCache(&parentFid, &dscp, userp, &req);
+ code = cm_GetSCache(&parentFid, NULL, &dscp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
req.flags |= CM_REQ_WOW64;
if (SourceID.Cell != 0) {
- Fid.cell = SourceID.Cell;
- Fid.volume = SourceID.Volume;
- Fid.vnode = SourceID.Vnode;
- Fid.unique = SourceID.Unique;
- Fid.hash = SourceID.Hash;
-
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ cm_SetFid(&Fid, SourceID.Cell, SourceID.Volume, SourceID.Vnode, SourceID.Unique);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
if (ParentID.Cell != 0) {
cm_SetFid(&parentFid, ParentID.Cell, ParentID.Volume, ParentID.Vnode, ParentID.Unique);
- code = cm_GetSCache(&parentFid, &dscp, userp, &req);
+ code = cm_GetSCache(&parentFid, NULL, &dscp, userp, &req);
if (code) {
cm_ReleaseSCache(scp);
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
cm_HoldSCache(dscp);
} else if (scp->parentVnode) {
cm_SetFid(&parentFid, SourceID.Cell, SourceID.Volume, scp->parentVnode, scp->parentUnique);
- code = cm_GetSCache(&parentFid, &dscp, userp, &req);
+ code = cm_GetSCache(&parentFid, NULL, &dscp, userp, &req);
if (code) {
cm_ReleaseSCache(scp);
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
parentFid.unique = CreateCB->ParentId.Unique;
parentFid.hash = CreateCB->ParentId.Hash;
- code = cm_GetSCache(&parentFid, &dscp, userp, &req);
+ code = cm_GetSCache(&parentFid, NULL, &dscp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
parentFid.unique = UpdateCB->ParentId.Unique;
parentFid.hash = UpdateCB->ParentId.Hash;
- code = cm_GetSCache(&parentFid, &dscp, userp, &req);
+ code = cm_GetSCache(&parentFid, NULL, &dscp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, &dscp->fid, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
parentFid.hash = CleanupCB->ParentId.Hash;
if (parentFid.cell) {
- code = cm_GetSCache(&parentFid, &dscp, userp, &req);
+ code = cm_GetSCache(&parentFid, NULL, &dscp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
if ( status == STATUS_INVALID_HANDLE)
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, &dscp->fid, &scp, userp, &req);
if (code) {
osi_Log1(afsd_logp, "RDR_CleanupFileEntry cm_GetSCache object FID failure code=0x%x",
code);
parentFid.unique = ParentId.Unique;
parentFid.hash = ParentId.Hash;
- code = cm_GetSCache(&parentFid, &dscp, userp, &req);
+ code = cm_GetSCache(&parentFid, NULL, &dscp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
if ( status == STATUS_INVALID_HANDLE)
TargetParentFid.unique = TargetParentId.Unique;
TargetParentFid.hash = TargetParentId.Hash;
- code = cm_GetSCache(&SourceParentFid, &oldDscp, userp, &req);
+ code = cm_GetSCache(&SourceParentFid, NULL, &oldDscp, userp, &req);
if (code) {
osi_Log1(afsd_logp, "RDR_RenameFileEntry cm_GetSCache source parent failed code 0x%x", code);
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
return;
}
- code = cm_GetSCache(&TargetParentFid, &newDscp, userp, &req);
+ code = cm_GetSCache(&TargetParentFid, NULL, &newDscp, userp, &req);
if (code) {
osi_Log1(afsd_logp, "RDR_RenameFileEntry cm_GetSCache target parent failed code 0x%x", code);
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
TargetFid.cell, TargetFid.volume,
TargetFid.vnode, TargetFid.unique);
- code = cm_GetSCache(&TargetFid, &scp, userp, &req);
+ code = cm_GetSCache(&TargetFid, &newDscp->fid, &scp, userp, &req);
if (code) {
osi_Log1(afsd_logp, "RDR_RenameFileEntry cm_GetSCache target failed code 0x%x", code);
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
osi_Log1(afsd_logp, "RDR_RequestFileExtentsAsync cm_GetSCache FID failure code=0x%x",
code);
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
goto cleanup_file;
}
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
osi_Log1(afsd_logp, "RDR_ProcessReleaseFileExtentsResult cm_GetSCache FID failure code=0x%x",
code);
goto cleanup_file;
}
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
osi_Log1(afsd_logp, "RDR_ReleaseFailedSetFileExtents cm_GetSCache FID failure code=0x%x",
code);
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
cm_ReleaseSCache(iop->parentScp);
iop->parentScp = NULL;
}
- cm_GetSCache(parentFid, &iop->parentScp, userp, &req);
+ cm_GetSCache(parentFid, NULL, &iop->parentScp, userp, &req);
iop->rootFid = *rootFid;
}
} else {
cm_HoldSCache(iop->parentScp);
} else {
iop->parentFid = *parentFid;
- cm_GetSCache(parentFid, &iop->parentScp, userp, &req);
+ cm_GetSCache(parentFid, NULL, &iop->parentScp, userp, &req);
}
if (rootFid->cell == 0) {
iop->rootFid = cm_data.rootFid;
}
}
} else {
- code = cm_GetSCache(&ioctlp->parentFid, &substRootp, userp, reqp);
+ code = cm_GetSCache(&ioctlp->parentFid, NULL, &substRootp, userp, reqp);
if (code) {
osi_Log1(afsd_logp,"RDR_ParseIoctlPath [6] code 0x%x", code);
if (free_path)
}
}
} else {
- code = cm_GetSCache(&ioctlp->rootFid, &substRootp, userp, reqp);
+ code = cm_GetSCache(&ioctlp->rootFid, NULL, &substRootp, userp, reqp);
if (code) {
osi_Log1(afsd_logp,"RDR_ParseIoctlParent [5] code 0x%x", code);
return code;
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = RDR_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = RDR_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = RDR_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = RDR_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = RDR_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = RDR_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = RDR_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = RDR_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = RDR_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = RDR_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = RDR_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = RDR_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_SkipIoctlPath(&ioctlp->ioctl);
cm_SetFid(&fid, optionsp->fid.cell, optionsp->fid.volume,
optionsp->fid.vnode, optionsp->fid.unique);
- code = cm_GetSCache(&fid, &scp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &scp, userp, &req);
} else {
code = RDR_ParseIoctlPath(ioctlp, userp, &req, &scp, flags);
}
cm_ReleaseSCache(pipep->parentScp);
pipep->parentScp = NULL;
}
- cm_GetSCache(parentFid, &pipep->parentScp, userp, &req);
+ cm_GetSCache(parentFid, NULL, &pipep->parentScp, userp, &req);
pipep->rootFid = *rootFid;
}
} else {
cm_HoldSCache(pipep->parentScp);
} else {
pipep->parentFid = *parentFid;
- cm_GetSCache(parentFid, &pipep->parentScp, userp, &req);
+ cm_GetSCache(parentFid, NULL, &pipep->parentScp, userp, &req);
}
if (rootFid->cell == 0) {
pipep->rootFid = cm_data.rootFid;