void ifs_InternalClose(cm_scache_t **scpp)
{
osi_assert(scpp && *scpp);
-
- lock_ObtainMutex(&((*scpp)->mx));
cm_ReleaseSCache(*scpp);
-
- lock_ReleaseMutex(&((*scpp)->mx));
*scpp = NULL;
}
afs_acc |= PRSFS_DELETE;
/* check ACL with server */
- lock_ObtainMutex(&(scp->mx));
+ lock_ObtainWrite(&scp->rw);
ifs_CheckAcl(scp, afs_acc, &afs_gr);
- lock_ReleaseMutex(&(scp->mx));
+ lock_ReleaseWrite(&scp->rw);
*granted = 0;
if (afs_gr & PRSFS_READ)
/* stat file; don't want callback */
cm_InitReq(&req);
- lock_ObtainMutex(&(scp->mx));
+ lock_ObtainWrite(&(scp->rw));
cm_HoldUser(userp);
code = cm_SyncOp(scp, NULL, userp, &req, 0, CM_SCACHESYNC_GETSTATUS);
cm_ReleaseUser(userp);
if (code)
- lock_ReleaseMutex(&(scp->mx));
+ lock_ReleaseWrite(&(scp->rw));
MAP_RETURN(code);
code = ifs_CopyInfo(scp, attribs, size, creation, access, change, written);
- lock_ReleaseMutex(&(scp->mx));
+ lock_ReleaseWrite(&(scp->rw));
MAP_RETURN(code);
return 0;
*/
cm_InitReq(&req);
- lock_ObtainMutex(&(scp->mx));
+ lock_ObtainWrite(&(scp->rw));
code = cm_SyncOp(scp, NULL, userp, &req, 0, CM_SCACHESYNC_GETSTATUS);
if (code)
- lock_ReleaseMutex(&(scp->mx));
+ lock_ReleaseWrite(&(scp->rw));
MAP_RETURN(code);
oldLen = scp->length;
- lock_ReleaseMutex(&(scp->mx));
+ lock_ReleaseWrite(&(scp->rw));
code = cm_SetLength(scp, &size, userp, &req);
MAP_RETURN(code);
}
{
- lock_ObtainMutex(&child_scp->mx);
+ lock_ObtainWrite(&child_scp->rw);
code = cm_SyncOp(child_scp, NULL, userp, &req, 0, CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
- lock_ReleaseMutex(&child_scp->mx);
+ lock_ReleaseWrite(&child_scp->rw);
}
if (code) /* perhaps blank fields we do not know, and continue. bad filents should not prevent readdirs. */
info->cookie = *offset;
- lock_ObtainMutex(&(child_scp->mx));
+ lock_ObtainWrite(&(child_scp->rw));
code = ifs_CopyInfo(child_scp, &info->attribs, &info->size, &info->creation, &info->access, &info->change, &info->write);
#if 0
/* make files we do not have write access to read-only */
if (gr & FILE_READ_DATA && !(gr & FILE_WRITE_DATA))
info->attribs |= FILE_ATTRIBUTE_READONLY;
#endif
- lock_ReleaseMutex(&(child_scp->mx));
+ lock_ReleaseWrite(&(child_scp->rw));
ifs_InternalClose(&child_scp);
MAP_RETURN(code);
SCPL_LOCK; /* perhaps this should be earlier */
- lock_ObtainMutex(&(scp->mx));
cm_ReleaseSCache(scp);
- lock_ReleaseMutex(&(scp->mx));
prev = NULL, curr = scp_list_head;
if (!aclScp)
return 0;
if (aclScp != scp) {
- code = lock_TryMutex(&aclScp->mx);
+ code = lock_TryRead(&aclScp->rw);
if (code == 0) {
/* can't get lock safely and easily */
cm_ReleaseSCache(aclScp);
/* check that we have a callback, too */
if (!cm_HaveCallback(aclScp)) {
/* can't use it */
- lock_ReleaseMutex(&aclScp->mx);
+ lock_ReleaseRead(&aclScp->rw);
cm_ReleaseSCache(aclScp);
return 0;
}
release = 1;
}
- lock_AssertMutex(&aclScp->mx);
+ lock_AssertAny(&aclScp->rw);
/* now if rights is a subset of the public rights, we're done.
* Otherwise, if we an explicit acl entry, we're also in good shape,
done:
if (didLock)
- lock_ReleaseMutex(&aclScp->mx);
+ lock_ReleaseRead(&aclScp->rw);
if (release)
cm_ReleaseSCache(aclScp);
return code;
} else {
/* not a dir, use parent dir's acl */
cm_SetFid(&tfid, scp->fid.cell, scp->fid.volume, scp->parentVnode, scp->parentUnique);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
code = cm_GetSCache(&tfid, &aclScp, userp, reqp);
if (code) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
goto _done;
}
osi_Log2(afsd_logp, "GetAccess parent scp %x user %x", aclScp, userp);
- lock_ObtainMutex(&aclScp->mx);
+ lock_ObtainWrite(&aclScp->rw);
code = cm_SyncOp(aclScp, NULL, userp, reqp, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_FORCECB);
if (!code)
cm_SyncOpDone(aclScp, NULL,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- lock_ReleaseMutex(&aclScp->mx);
+ lock_ReleaseWrite(&aclScp->rw);
cm_ReleaseSCache(aclScp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
}
_done:
/*
* Remove the entry from the vnode's list
*/
- lock_AssertMutex(&aclp->backp->mx);
+ lock_AssertWrite(&aclp->backp->rw);
laclpp = &aclp->backp->randomACLp;
for (taclp = *laclpp; taclp; laclpp = &taclp->nextp, taclp = *laclpp) {
if (taclp == aclp)
if (aclp->backp && scp != aclp->backp) {
ascp = aclp->backp;
lock_ReleaseWrite(&cm_aclLock);
- lock_ObtainMutex(&ascp->mx);
+ lock_ObtainWrite(&ascp->rw);
lock_ObtainWrite(&cm_aclLock);
}
CleanupACLEnt(aclp);
if (ascp)
- lock_ReleaseMutex(&ascp->mx);
+ lock_ReleaseWrite(&ascp->rw);
return aclp;
}
release = 1;
}
if ( scp ) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainRead(&scp->rw);
if (scp->flags & CM_SCACHEFLAG_WAITING) {
osi_Log1(buf_logp, "buf_WaitIO waking scp 0x%p", scp);
osi_Wakeup((LONG_PTR)&scp->flags);
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseRead(&scp->rw);
}
}
LargeIntegerLessThan(*sizep, bufEnd)) {
buf_WaitIO(scp, bufp);
}
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
/* make sure we have a callback (so we have the right value for
* the length), and wait for it to be safe to do a truncate.
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS
| CM_SCACHESYNC_SETSIZE | CM_SCACHESYNC_BUFLOCKED);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ReleaseMutex(&bufp->mx);
if (!code) {
return code;
}
-/* Must be called with scp->mx held */
+/* Must be called with scp->rw held */
long buf_ForceDataVersion(cm_scache_t * scp, afs_uint64 fromVersion, afs_uint64 toVersion)
{
cm_buf_t * bp;
afs_uint32 i;
int found = 0;
- lock_AssertMutex(&scp->mx);
+ lock_AssertAny(&scp->rw);
i = BUF_FILEHASH(&scp->fid);
osi_Log4(afsd_logp, "RevokeCallback Discarding SCache scp 0x%p vol %u vn %u uniq %u",
scp, scp->fid.volume, scp->fid.vnode, scp->fid.unique);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_DiscardSCache(scp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_CallbackNotifyChange(scp);
cm_HoldSCacheNoLock(scp);
lock_ReleaseWrite(&cm_scacheLock);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
osi_Log4(afsd_logp, "RevokeVolumeCallback Discarding SCache scp 0x%p vol %u vn %u uniq %u",
scp, scp->fid.volume, scp->fid.vnode, scp->fid.unique);
cm_DiscardSCache(scp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_CallbackNotifyChange(scp);
lock_ObtainWrite(&cm_scacheLock);
for (scp=cm_data.scacheHashTablep[hash]; scp; scp=scp->nextp) {
cm_HoldSCacheNoLock(scp);
lock_ReleaseWrite(&cm_scacheLock);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
discarded = 0;
if (scp->cbExpires > 0 && scp->cbServerp != NULL) {
/* we have a callback, now decide if we should clear it */
discarded = 1;
}
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (discarded)
cm_CallbackNotifyChange(scp);
lock_ObtainWrite(&cm_scacheLock);
cep->netFid.Vnode = scp->fid.vnode;
cep->netFid.Unique = scp->fid.unique;
cep->lock.waitStates = 0;
- cep->lock.exclLocked = scp->mx.flags;
+ cep->lock.exclLocked = scp->rw.flags;
cep->lock.readersReading = 0;
- cep->lock.numWaiting = scp->mx.waiters;
+ cep->lock.numWaiting = scp->rw.waiters;
cep->lock.pid_last_reader = 0;
cep->lock.pid_writer = 0;
cep->lock.src_indicator = 0;
cep->netFid.Vnode = scp->fid.vnode;
cep->netFid.Unique = scp->fid.unique;
cep->lock.waitStates = 0;
- cep->lock.exclLocked = scp->mx.flags;
+ cep->lock.exclLocked = scp->rw.flags;
cep->lock.readersReading = 0;
- cep->lock.numWaiting = scp->mx.waiters;
+ cep->lock.numWaiting = scp->rw.waiters;
cep->lock.pid_last_reader = 0;
cep->lock.pid_writer = 0;
cep->lock.src_indicator = 0;
} else if (fdc==2 && !fgc) { // we're in good shape
if (cm_getLocalMountPointChange()) { // check for changes
cm_clearLocalMountPointChange(); // clear the changefile
- lock_ReleaseMutex(&scp->mx); // this is re-locked in reInitLocalMountPoints
+ lock_ReleaseWrite(&scp->rw); // this is re-locked in reInitLocalMountPoints
cm_reInitLocalMountPoints(); // start reinit
- lock_ObtainMutex(&scp->mx); // now get the lock back
+ lock_ObtainWrite(&scp->rw); // now get the lock back
return 0;
}
return 1; // no change
/* Called at the end of a callback-granting call, to remove the callback
* info from the scache entry, if necessary.
*
- * Called with scp locked, so we can discard the callbacks easily with
+ * Called with scp write locked, so we can discard the callbacks easily with
* this locking hierarchy.
*/
void cm_EndCallbackGrantingCall(cm_scache_t *scp, cm_callbackRequest_t *cbrp,
if ( discardScp ) {
cm_DiscardSCache(scp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_CallbackNotifyChange(scp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
}
if ( serverp ) {
}
cm_StartCallbackGrantingCall(scp, &cbr);
sfid = scp->fid;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
/* now make the RPC */
osi_Log4(afsd_logp, "CALL FetchStatus scp 0x%p vol %u vn %u uniq %u",
osi_Log4(afsd_logp, "CALL FetchStatus SUCCESS scp 0x%p vol %u vn %u uniq %u",
scp, scp->fid.volume, scp->fid.vnode, scp->fid.unique);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code == 0) {
cm_EndCallbackGrantingCall(scp, &cbr, &callback, 0);
cm_MergeStatus(NULL, scp, &afsStatus, &volSync, userp, 0);
osi_Log4(afsd_logp, "Callback Expiration Discarding SCache scp 0x%p vol %u vn %u uniq %u",
scp, scp->fid.volume, scp->fid.vnode, scp->fid.unique);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_DiscardSCache(scp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_CallbackNotifyChange(scp);
lock_ObtainWrite(&cm_scacheLock);
pscp = cm_FindSCacheParent(scp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
lock_ObtainWrite(&cm_scacheLock);
cm_RemoveSCacheFromHashTable(scp);
lock_ReleaseWrite(&cm_scacheLock);
cm_LockMarkSCacheLost(scp);
scp->flags |= CM_SCACHEFLAG_DELETED;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
if (pscp) {
if (cm_HaveCallback(pscp)) {
- lock_ObtainMutex(&pscp->mx);
+ lock_ObtainWrite(&pscp->rw);
cm_DiscardSCache(pscp);
- lock_ReleaseMutex(&pscp->mx);
+ lock_ReleaseWrite(&pscp->rw);
}
cm_ReleaseSCache(pscp);
}
* buffer, although more likely it will just return a new, empty, buffer.
*/
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (scp->flags & CM_SCACHEFLAG_DELETED) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
return CM_ERROR_NOSUCHFILE;
}
code = cm_SetupStoreBIOD(scp, offsetp, length, &biod, userp, reqp);
if (code) {
osi_Log1(afsd_logp, "cm_SetupStoreBIOD code %x", code);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
return code;
}
if (biod.length == 0) {
osi_Log0(afsd_logp, "cm_SetupStoreBIOD length 0");
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseBIOD(&biod, 1, 0); /* should be a NOOP */
return 0;
}
require_64bit_ops = 1;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
/* now we're ready to do the store operation */
do {
osi_Log1(afsd_logp, "CALL StoreData SUCCESS scp 0x%p", scp);
/* now, clean up our state */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_STOREDATA_EXCL);
else if (code == CM_ERROR_QUOTA)
scp->flags |= CM_SCACHEFLAG_OVERQUOTA;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseBIOD(&biod, 1, code);
return code;
require_64bit_ops = 1;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_AFSFidFromFid(&tfid, &scp->fid);
code = cm_MapRPCError(code, reqp);
/* now, clean up our state */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_STOREDATA_EXCL);
cm_scache_t *scp = vscp;
long code;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, reqp, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_SETSIZE);
if (code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
return code;
}
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_SETSIZE);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
/* always succeeds */
return 0;
tlength = *length;
tblocksize = ConvertLongToLargeInteger(cm_data.buf_blockSize);
stop = 0;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
while (LargeIntegerGreaterThanZero(tlength)) {
/* get callback so we can do a meaningful dataVersion comparison */
code = cm_SyncOp(scp, NULL, userp, reqp, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code) {
scp->flags &= ~CM_SCACHEFLAG_PREFETCHING;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
return code;
}
*realBasep = tbase;
code = 0;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
return code;
}
osi_Log4(afsd_logp, "Finished BKG store scp 0x%p, offset 0x%x:%08x, code 0x%x", scp, p2, p1, code);
}
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_ASYNCSTORE);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
return code;
}
offset = LargeIntegerAdd(offset, tblocksize) )
{
if (mxheld) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
mxheld = 0;
}
}
if (!mxheld) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
mxheld = 1;
}
}
if (!mxheld) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
mxheld = 1;
}
cm_ClearPrefetchFlag(LargeIntegerGreaterThanZero(fetched) ? 0 : code,
scp, &base, &fetched);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
osi_Log4(afsd_logp, "Ending BKG prefetch scp 0x%p, code %d bytes 0x%x:%x",
scp, code, fetched.HighPart, fetched.LowPart);
readLength = ConvertLongToLargeInteger(count);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if ((scp->flags & CM_SCACHEFLAG_PREFETCHING)
|| LargeIntegerLessThanOrEqualTo(readBase, scp->prefetch.base)) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
return;
}
scp->flags |= CM_SCACHEFLAG_PREFETCHING;
if (LargeIntegerGreaterThan(scp->prefetch.end, readBase))
readBase = scp->prefetch.end;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
code = cm_CheckFetchRange(scp, &readBase, &readLength, userp, reqp,
&realBase);
biop->reserved = 0;
/* reserve a chunk's worth of buffers */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
buf_ReserveBuffers(cm_chunkSize / cm_data.buf_blockSize);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
bufp = NULL;
for (temp = 0; temp < inSize; temp += cm_data.buf_blockSize) {
bufp = buf_Find(scp, &tbase);
if (bufp) {
/* get buffer mutex and scp mutex safely */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ObtainMutex(&bufp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
flags = CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_STOREDATA | CM_SCACHESYNC_BUFLOCKED;
code = cm_SyncOp(scp, bufp, userp, reqp, 0, flags);
break;
/* try to lock it, and quit if we can't (simplifies locking) */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
code = lock_TryMutex(&bufp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code == 0) {
buf_Release(bufp);
bufp = NULL;
break;
/* try to lock it, and quit if we can't (simplifies locking) */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
code = lock_TryMutex(&bufp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code == 0) {
buf_Release(bufp);
bufp = NULL;
/* copy out size, since it may change */
fileSize = scp->serverLength;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
pageBase = *offsetp;
collected = pageBase.LowPart & (cm_chunkSize - 1);
code = buf_Get(scp, &pageBase, &tbp);
if (code) {
//lock_ReleaseMutex(&cm_bufGetMutex);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
return code;
}
/* now lock the buffer lock */
lock_ObtainMutex(&tbp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
/* don't bother fetching over data that is already current */
if (tbp->dataVersion <= scp->dataVersion && tbp->dataVersion >= scp->bufDataVersionLow) {
/* we don't need this buffer, since it is current */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ReleaseMutex(&tbp->mx);
break;
}
*/
code = cm_SyncOp(scp, tbp, userp, reqp, 0, flags);
if (code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ReleaseMutex(&tbp->mx);
break;
}
/* don't fetch over dirty buffers */
if (tbp->flags & CM_BUF_DIRTY) {
cm_SyncOpDone(scp, tbp, flags);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ReleaseMutex(&tbp->mx);
break;
}
/* Release locks */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ReleaseMutex(&tbp->mx);
/* add the buffer to the list */
}
/* Caller expects this */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
/* if we got a failure setting up the first buffer, then we don't have
* any side effects yet, and we also have failed an operation that the
/* now, mark I/O as done, unlock the buffer and release it */
lock_ObtainMutex(&bufp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_SyncOpDone(scp, bufp, flags);
/* turn off writing and wakeup users */
}
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ReleaseMutex(&bufp->mx);
buf_Release(bufp);
bufp = NULL;
}
} else {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_SyncOpDone(scp, NULL, flags);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
}
/* clean things out */
memset(bufp->datap, 0, cm_data.buf_blockSize);
bufp->dataVersion = scp->dataVersion;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseBIOD(&biod, 0, 0);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
return 0;
} else if ((bufp->dataVersion == CM_BUF_VERSION_BAD || bufp->dataVersion < scp->bufDataVersionLow)
&& (scp->mask & CM_SCACHEMASK_TRUNCPOS) &&
LargeIntegerGreaterThanOrEqualTo(bufp->offset, scp->truncPos)) {
memset(bufp->datap, 0, cm_data.buf_blockSize);
bufp->dataVersion = scp->dataVersion;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseBIOD(&biod, 0, 0);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
return 0;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (LargeIntegerGreaterThan(LargeIntegerAdd(biod.offset,
ConvertLongToLargeInteger(biod.length)),
* this buffer will start a prefetch.
*/
tbufp->cmFlags |= CM_BUF_CMFULLYFETCHED;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (scp->flags & CM_SCACHEFLAG_WAITING) {
osi_Log1(afsd_logp, "CM GetBuffer Waking scp 0x%p", scp);
osi_Wakeup((LONG_PTR) &scp->flags);
*cpffp = 1;
cm_ClearPrefetchFlag(0, scp, &biod.offset, &tlength);
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
/* and adjust counters */
nbytes -= temp;
fetchingcompleted:
code = cm_MapRPCError(code, reqp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_FETCHSTATUS);
}
/* release scatter/gather I/O structure (buffers, locks) */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseBIOD(&biod, 0, code);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code == 0)
cm_MergeStatus(NULL, scp, &afsStatus, &volSync, userp, 0);
entry is a string name.
On entry:
- op->scp->mx is unlocked
+ op->scp->rw is unlocked
On exit:
- op->scp->mx is unlocked
+ op->scp->rw is unlocked
None of the directory buffers for op->scp should be locked by the
calling thread.
/* Return the length of a directory in pages
On entry:
- op->scp->mx is locked
+ op->scp->rw is locked
On exit:
- op->scp->mx is locked
+ op->scp->rw is locked
The first directory page for op->scp should not be locked by the
calling thread.
/* Delete a directory entry.
On entry:
- op->scp->mx is unlocked
+ op->scp->rw is unlocked
On exit:
- op->scp->mx is unlocked
+ op->scp->rw is unlocked
None of the directory buffers for op->scp should be locked by the
calling thread.
/* Find a bunch of contiguous entries; at least nblobs in a row.
- Called with op->scp->mx */
+ Called with op->scp->rw */
static long
cm_DirFindBlobs(cm_dirOp_t * op, int nblobs)
{
/* Add a page to a directory.
- Called with op->scp->mx
+ Called with op->scp->rw
*/
static long
cm_DirAddPage(cm_dirOp_t * op, int pageno)
/* Free a whole bunch of directory entries.
- Called with op->scp->mx
+ Called with op->scp->rw
*/
static long
cm_DirFreeBlobs(cm_dirOp_t * op, int firstblob, int nblobs)
* directory header page are allocated, 1 to the page header, 4 to the
* allocation map and 8 to the hash table.
*
- * Called with op->scp->mx unlocked
+ * Called with op->scp->rw unlocked
*/
int
cm_DirMakeDir(cm_dirOp_t * op, cm_fid_t * me, cm_fid_t * parent)
/* Look up a file name in directory.
On entry:
- op->scp->mx is unlocked
+ op->scp->rw is unlocked
On exit:
- op->scp->mx is unlocked
+ op->scp->rw is unlocked
None of the directory buffers for op->scp should be locked by the
calling thread.
/* Look up a file name in directory.
On entry:
- op->scp->mx is locked
+ op->scp->rw is locked
On exit:
- op->scp->mx is locked
+ op->scp->rw is locked
None of the directory buffers for op->scp should be locked by the
calling thread.
/* Apply a function to every directory entry in a directory.
On entry:
- op->scp->mx is locked
+ op->scp->rw is locked
On exit:
- op->scp->mx is locked
+ op->scp->rw is locked
None of the directory buffers for op->scp should be locked by the
calling thread.
/* Check if a directory is empty
On entry:
- op->scp->mx is locked
+ op->scp->rw is locked
On exit:
- op->scp->mx is locked
+ op->scp->rw is locked
None of the directory buffers for op->scp should be locked by the
calling thread.
/* Return a pointer to an entry, given its number.
On entry:
- scp->mx locked
+ scp->rw locked
if *bufferpp != NULL, then *bufferpp->mx is locked
During:
- scp->mx may be unlocked
+ scp->rw may be unlocked
*bufferpp may be released
On exit:
- scp->mx locked
+ scp->rw locked
if *bufferpp != NULL, then *bufferpp->mx is locked
*bufferpp should be released via cm_DirReleasePage() or any other
* pointer is returned instead.
*
* On entry:
- * scp->mx locked
+ * scp->rw locked
*
* On exit:
- * scp->mx locked
+ * scp->rw locked
*/
static long
cm_DirFindItem(cm_dirOp_t * op,
}
/* Begin a sequence of directory operations.
- * Called with scp->mx unlocked.
+ * Called with scp->rw unlocked.
*/
long
cm_BeginDirOp(cm_scache_t * scp, cm_user_t * userp, cm_req_t * reqp,
lock_ObtainRead(&scp->dirlock);
haveWrite = 0;
}
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
mxheld = 1;
code = cm_DirCheckStatus(op, 1);
if (code == 0) {
repeat:
if (!haveWrite) {
if (mxheld) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
mxheld = 0;
}
lock_ConvertRToW(&scp->dirlock);
haveWrite = 1;
}
if (!mxheld) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
mxheld = 1;
}
if (scp->dirBplus &&
if (!scp->dirBplus) {
if (mxheld) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
mxheld = 0;
}
cm_BPlusDirBuildTree(scp, userp, reqp);
if (!mxheld) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
mxheld = 1;
}
if (op->dataVersion != scp->dataVersion) {
#endif
op->lockType = lockType;
if (mxheld)
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
} else {
if (haveWrite)
lock_ReleaseWrite(&scp->dirlock);
else
lock_ReleaseRead(&scp->dirlock);
if (mxheld)
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_EndDirOp(op);
}
}
/* Check if it is safe for us to perform local directory updates.
- Called with scp->mx unlocked. */
+ Called with scp->rw unlocked. */
int
cm_CheckDirOpForSingleChange(cm_dirOp_t * op)
{
if (op->scp == NULL)
return 0;
- lock_ObtainMutex(&op->scp->mx);
+ lock_ObtainWrite(&op->scp->rw);
code = cm_DirCheckStatus(op, 1);
if (code == 0 &&
rc = 1;
}
- lock_ReleaseMutex(&op->scp->mx);
+ lock_ReleaseWrite(&op->scp->rw);
if (rc)
osi_Log0(afsd_logp, "cm_CheckDirOpForSingleChange succeeded");
}
/* End a sequence of directory operations.
- * Called with op->scp->mx unlocked.*/
+ * Called with op->scp->rw unlocked.*/
long
cm_EndDirOp(cm_dirOp_t * op)
{
/* we made changes. We should go through the list of buffers
* and update the dataVersion for each. */
- lock_ObtainMutex(&op->scp->mx);
+ lock_ObtainWrite(&op->scp->rw);
code = buf_ForceDataVersion(op->scp, op->dataVersion, op->newDataVersion);
- lock_ReleaseMutex(&op->scp->mx);
+ lock_ReleaseWrite(&op->scp->rw);
}
switch (op->lockType) {
return code;
}
-/* NOTE: Called without scp->mx and without bufferp->mx */
+/* NOTE: Called without scp->rw and without bufferp->mx */
static long
cm_DirOpAddBuffer(cm_dirOp_t * op, cm_buf_t * bufferp)
{
osi_assert(i < CM_DIROP_MAXBUFFERS);
lock_ObtainMutex(&bufferp->mx);
- lock_ObtainMutex(&op->scp->mx);
+ lock_ObtainWrite(&op->scp->rw);
/* Make sure we are synchronized. */
osi_assert(op->lockType != CM_DIRLOCK_NONE);
code = CM_ERROR_INVAL;
}
- lock_ReleaseMutex(&op->scp->mx);
+ lock_ReleaseWrite(&op->scp->rw);
lock_ReleaseMutex(&bufferp->mx);
if (code) {
}
}
-/* Note: Called without op->scp->mx */
+/* Note: Called without op->scp->rw */
static int
cm_DirOpFindBuffer(cm_dirOp_t * op, osi_hyper_t offset, cm_buf_t ** bufferpp)
{
}
-/* NOTE: called with scp->mx held or not depending on the flags */
+/* NOTE: called with scp->rw held or not depending on the flags */
static int
cm_DirOpDelBuffer(cm_dirOp_t * op, cm_buf_t * bufferp, int flags)
{
version of the buffer with the data version of the
scp. */
if (!(flags & DIROP_SCPLOCKED)) {
- lock_ObtainMutex(&op->scp->mx);
+ lock_ObtainWrite(&op->scp->rw);
}
/* first make sure that the buffer is idle. It should
osi_assert(bufferp->dataVersion == op->dataVersion);
#endif
- lock_ReleaseMutex(&op->scp->mx);
+ lock_ReleaseWrite(&op->scp->rw);
lock_ObtainMutex(&bufferp->mx);
if (flags & DIROP_SCPLOCKED) {
- lock_ObtainMutex(&op->scp->mx);
+ lock_ObtainWrite(&op->scp->rw);
}
if (flags & DIROP_MODIFIED) {
This should be called before cm_DirGetPage() is called per scp.
On entry:
- scp->mx locked state indicated by parameter
+ scp->rw locked state indicated by parameter
On exit:
- scp->mx same state as upon entry
+ scp->rw same state as upon entry
During:
- scp->mx may be released
+ scp->rw may be released
*/
static long
cm_DirCheckStatus(cm_dirOp_t * op, afs_uint32 locked)
long code;
if (!locked)
- lock_ObtainMutex(&op->scp->mx);
+ lock_ObtainWrite(&op->scp->rw);
code = cm_SyncOp(op->scp, NULL, op->userp, &op->req, PRSFS_LOOKUP,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (!locked)
- lock_ReleaseMutex(&op->scp->mx);
+ lock_ReleaseWrite(&op->scp->rw);
osi_Log2(afsd_logp, "cm_DirCheckStatus for op 0x%p returning code 0x%x",
op, code);
cm_DirGetPage() or any other function that returns a locked, held,
directory page buffer.
- Called with scp->mx unlocked
+ Called with scp->rw unlocked
*/
static long
cm_DirReleasePage(cm_dirOp_t * op, cm_buf_t ** bufferpp, int modified)
should be released via cm_DirReleasePage().
On entry:
- scp->mx unlocked.
+ scp->rw unlocked.
If *bufferpp is non-NULL, then *bufferpp->mx is locked.
On exit:
- scp->mx unlocked
+ scp->rw unlocked
If *bufferpp is non-NULL, then *bufferpp->mx is locked.
During:
- scp->mx will be obtained and released
+ scp->rw will be obtained and released
*/
static long
doing directory updates locally is to avoid fetching all
the data from the server. */
while (1) {
- lock_ObtainMutex(&op->scp->mx);
+ lock_ObtainWrite(&op->scp->rw);
code = cm_SyncOp(op->scp, bufferp, op->userp, &op->req, PRSFS_LOOKUP,
CM_SCACHESYNC_NEEDCALLBACK |
CM_SCACHESYNC_READ |
CM_SCACHESYNC_BUFLOCKED);
if (code) {
- lock_ReleaseMutex(&op->scp->mx);
+ lock_ReleaseWrite(&op->scp->rw);
break;
}
CM_SCACHESYNC_BUFLOCKED);
if (cm_HaveBuffer(op->scp, bufferp, 1)) {
- lock_ReleaseMutex(&op->scp->mx);
+ lock_ReleaseWrite(&op->scp->rw);
break;
}
lock_ReleaseMutex(&bufferp->mx);
code = cm_GetBuffer(op->scp, bufferp, NULL, op->userp, &op->req);
- lock_ReleaseMutex(&op->scp->mx);
+ lock_ReleaseWrite(&op->scp->rw);
lock_ObtainMutex(&bufferp->mx);
if (code)
// mark the scp to be reused
cm_HoldSCacheNoLock(scp);
lock_ReleaseWrite(&cm_scacheLock);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_DiscardSCache(scp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_CallbackNotifyChange(scp);
lock_ObtainWrite(&cm_scacheLock);
cm_ReleaseSCacheNoLock(scp);
lscpp = &tscp->nextp, tscp = tscp->nextp) {
if (tscp == scp) {
*lscpp = scp->nextp;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
scp->flags &= ~CM_SCACHEFLAG_INHASH;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
break;
}
}
code = buf_CleanVnode(scp, userp, reqp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_DiscardSCache(scp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
osi_Log2(afsd_logp,"cm_CleanFile scp 0x%x returns error: [%x]",scp, code);
return code;
code = buf_FlushCleanPages(scp, userp, reqp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_DiscardSCache(scp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
osi_Log2(afsd_logp,"cm_FlushFile scp 0x%x returns error: [%x]",scp, code);
return code;
for (scp=cm_data.scacheHashTablep[hash]; scp; scp=scp->nextp) {
cm_HoldSCacheNoLock(scp);
lock_ReleaseWrite(&cm_scacheLock);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_InvalidateACLUser(scp, userp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ObtainWrite(&cm_scacheLock);
cm_ReleaseSCacheNoLock(scp);
}
code = cm_MapRPCError(code, &req);
/* invalidate cache info, since we just trashed the ACL cache */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_DiscardSCache(scp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
}
cm_ReleaseSCache(scp);
cm_ReleaseSCache(dscp);
if (code) return code;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
/* now check that this is a real mount point */
if (scp->fileType != CM_SCACHETYPE_MOUNTPOINT) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
return CM_ERROR_INVAL;
}
cp += strlen(cp) + 1;
ioctlp->outDatap = cp;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
return code;
goto done2;
}
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
goto done2;
}
/* now check that this is a real mount point */
if (scp->fileType != CM_SCACHETYPE_MOUNTPOINT) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
code = CM_ERROR_INVAL;
goto done1;
}
/* time to make the RPC, so drop the lock */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
/* easier to do it this way */
dscp, cp, NULL, TRUE);
done1:
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
done2:
cm_ReleaseSCache(dscp);
if (code)
goto done3;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code)
}
/* time to make the RPC, so drop the lock */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
/* easier to do it this way */
code = cm_Unlink(dscp, cp, userp, &req);
| FILE_NOTIFY_CHANGE_DIR_NAME,
dscp, cp, NULL, TRUE);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
done1:
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
done2:
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
done3:
"invalid cm_scache_t address");
memset(scp, 0, sizeof(cm_scache_t));
scp->magic = CM_SCACHE_MAGIC;
- lock_InitializeMutex(&scp->mx, "cm_scache_t mutex");
+ lock_InitializeRWLock(&scp->rw, "cm_scache_t rw");
lock_InitializeRWLock(&scp->bufCreateLock, "cm_scache_t bufCreateLock");
#ifdef USE_BPLUS
lock_InitializeRWLock(&scp->dirlock, "cm_scache_t dirlock");
cm_data.fakeSCache.linkCount = 1;
cm_data.fakeSCache.refCount = 1;
}
- lock_InitializeMutex(&cm_data.fakeSCache.mx, "cm_scache_t mutex");
+ lock_InitializeRWLock(&cm_data.fakeSCache.rw, "cm_scache_t rw");
}
long
for ( scp = cm_data.allSCachesp; scp;
scp = scp->allNextp ) {
if (scp->randomACLp) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_FreeAllACLEnts(scp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
}
if (scp->cbServerp) {
scp->dirDataVersion = -1;
lock_FinalizeRWLock(&scp->dirlock);
#endif
- lock_FinalizeMutex(&scp->mx);
+ lock_FinalizeRWLock(&scp->rw);
lock_FinalizeRWLock(&scp->bufCreateLock);
}
lock_ReleaseWrite(&cm_scacheLock);
for ( scp = cm_data.allSCachesp; scp;
scp = scp->allNextp ) {
- lock_InitializeMutex(&scp->mx, "cm_scache_t mutex");
+ lock_InitializeRWLock(&scp->rw, "cm_scache_t rw");
lock_InitializeRWLock(&scp->bufCreateLock, "cm_scache_t bufCreateLock");
#ifdef USE_BPLUS
lock_InitializeRWLock(&scp->dirlock, "cm_scache_t dirlock");
* assume that no one else is using the one this is returned.
*/
lock_ReleaseWrite(&cm_scacheLock);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
lock_ObtainWrite(&cm_scacheLock);
#endif
scp->fid = *fidp;
scp->bufDataVersionLow=cm_data.fakeDirVersion;
scp->lockDataVersion=-1; /* no lock yet */
#if not_too_dangerous
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
#endif
*outScpp = scp;
lock_ReleaseWrite(&cm_scacheLock);
* assume that no one else is using the one this is returned.
*/
lock_ReleaseWrite(&cm_scacheLock);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
lock_ObtainWrite(&cm_scacheLock);
#endif
scp->fid = *fidp;
scp->refCount = 1;
osi_Log1(afsd_logp,"cm_GetSCache sets refCount to 1 scp 0x%x", scp);
#if not_too_dangerous
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
#endif
/* XXX - The following fields in the cm_scache are
lock_ReleaseMutex(&bufp->mx);
code = cm_GetCallback(scp, userp, reqp, (flags & CM_SCACHESYNC_FORCECB)?1:0);
if (bufLocked) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ObtainMutex(&bufp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
}
if (code)
return code;
if (bufLocked) lock_ReleaseMutex(&bufp->mx);
code = cm_GetAccessRights(scp, userp, reqp);
if (bufLocked) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ObtainMutex(&bufp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
}
if (code)
return code;
do {
if (bufLocked)
lock_ReleaseMutex(&bufp->mx);
- osi_SleepM((LONG_PTR) &scp->flags, &scp->mx);
+ osi_SleepW((LONG_PTR) &scp->flags, &scp->rw);
if (bufLocked)
lock_ObtainMutex(&bufp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
} while (!cm_SyncOpCheckContinue(scp, flags, bufp));
smb_UpdateServerPriority();
osi_queueData_t *qdp;
cm_buf_t *tbufp;
- lock_AssertMutex(&scp->mx);
+ lock_AssertWrite(&scp->rw);
/* now, update the recorded state for RPC-type calls */
if (flags & CM_SCACHESYNC_FETCHSTATUS)
*/
void cm_DiscardSCache(cm_scache_t *scp)
{
- lock_AssertMutex(&scp->mx);
+ lock_AssertWrite(&scp->rw);
if (scp->cbServerp) {
cm_PutServer(scp->cbServerp);
scp->cbServerp = NULL;
osi_queue_t q; /* list of all locks [protected by
cm_scacheLock] */
osi_queue_t fileq; /* per-file list of locks [protected
- by scp->mx]*/
+ by scp->rw]*/
cm_user_t *userp; /* The user to which this lock belongs
to [immutable; held] */
struct cm_scache *nextp; /* next in hash; cm_scacheLock */
struct cm_scache *allNextp; /* next in all scache list; cm_scacheLock */
cm_fid_t fid;
- afs_uint32 flags; /* flags; locked by mx */
+ afs_uint32 flags; /* flags; locked by rw */
/* synchronization stuff */
- osi_mutex_t mx; /* mutex for this structure */
+ osi_rwlock_t rw; /* rwlock for this structure */
osi_rwlock_t bufCreateLock; /* read-locked during buffer creation;
* write-locked to prevent buffers from
* being created during a truncate op, etc.
afs_int32 serverLock; /* current lock we have acquired on
* this file. One of (-1), LockRead
* or LockWrite. [protected by
- * scp->mx]. In the future, this
+ * scp->rw]. In the future, this
* should be replaced by a queue of
* cm_server_lock_t objects which keep
* track of lock type, the user for
if (openMode == 1 || openMode == 2 || trunc)
rights |= PRSFS_WRITE;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, reqp, rights,
CM_SCACHESYNC_GETSTATUS
_done:
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
return code;
}
if (desiredAccess & AFS_ACCESS_WRITE)
rights |= PRSFS_WRITE;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, reqp, rights,
CM_SCACHESYNC_GETSTATUS
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_LOCK);
_done:
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
osi_Log3(afsd_logp,"cm_CheckNTOpen scp 0x%p ldp 0x%p code 0x%x", scp, *ldpp, code);
return code;
{
osi_Log2(afsd_logp,"cm_CheckNTOpenDone scp 0x%p ldp 0x%p", scp, *ldpp);
if (*ldpp) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_Unlock(scp, (*ldpp)->sLockType, (*ldpp)->LOffset, (*ldpp)->LLength,
(*ldpp)->key, userp, reqp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
free(*ldpp);
*ldpp = NULL;
}
unsigned short *hashTable;
unsigned int i, idx;
int BeyondPage = 0, HaveDot = 0, HaveDotDot = 0;
+ int releaseLock = 0;
/* First check permissions */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, reqp, PRSFS_DELETE,
CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (code)
return code;
return code;
lock_ObtainMutex(&bufferp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
+ releaseLock = 1;
while (1) {
code = cm_SyncOp(scp, bufferp, userp, reqp, 0,
CM_SCACHESYNC_NEEDCALLBACK
| CM_SCACHESYNC_READ
| CM_SCACHESYNC_BUFLOCKED);
if (code)
- break;
+ goto done;
if (cm_HaveBuffer(scp, bufferp, 1))
break;
/* otherwise, load the buffer and try again */
lock_ReleaseMutex(&bufferp->mx);
code = cm_GetBuffer(scp, bufferp, NULL, userp, reqp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ObtainMutex(&bufferp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_SyncOpDone(scp, bufferp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ | CM_SCACHESYNC_BUFLOCKED);
if (code)
- break;
+ goto done;
}
+ lock_ReleaseWrite(&scp->rw);
+ releaseLock = 0;
+
/* We try to determine emptiness without looking beyond the first page,
* and without assuming "." and ".." are present and are on the first
* page (though these assumptions might, after all, be reasonable).
done:
lock_ReleaseMutex(&bufferp->mx);
buf_Release(bufferp);
- lock_ReleaseMutex(&scp->mx);
+ if (releaseLock)
+ lock_ReleaseWrite(&scp->rw);
return code;
}
int numDirChunks; /* # of 32 byte dir chunks in this entry */
/* get the directory size */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, reqp, PRSFS_LOOKUP,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (code)
return code;
routine is used in place of smb_ReceiveCoreSearchDir. our
other option is to modify smb_ReceiveCoreSearchDir itself,
but this seems to be the proper use for cm_ApplyDir. */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if ((scp->flags & CM_SCACHEFLAG_BULKSTATTING) == 0
&& (scp->bulkStatProgress.QuadPart <= thyper.QuadPart))
{
scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
scp->bulkStatProgress = thyper;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
#endif
lock_ObtainMutex(&bufferp->mx);
/* now get the data in the cache */
while (1) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, bufferp, userp, reqp,
PRSFS_LOOKUP,
CM_SCACHESYNC_NEEDCALLBACK
| CM_SCACHESYNC_READ
| CM_SCACHESYNC_BUFLOCKED);
if (code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
break;
}
cm_SyncOpDone(scp, bufferp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ | CM_SCACHESYNC_BUFLOCKED);
if (cm_HaveBuffer(scp, bufferp, 1)) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
break;
}
lock_ReleaseMutex(&bufferp->mx);
code = cm_GetBuffer(scp, bufferp, NULL, userp,
reqp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ObtainMutex(&bufferp->mx);
if (code)
break;
}
/* read the contents of a mount point into the appropriate string.
- * called with locked scp, and returns with locked scp.
+ * called with write locked scp, and returns with locked scp.
*/
long cm_ReadMountPoint(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
{
return 0;
/* otherwise, we have to read it in */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
thyper.LowPart = thyper.HighPart = 0;
code = buf_Get(scp, &thyper, &bufp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code)
return code;
/* called with a locked scp and chases the mount point, yielding outScpp.
- * scp remains locked, just for simplicity of describing the interface.
+ * scp remains write locked, just for simplicity of describing the interface.
*/
long cm_FollowMountPoint(cm_scache_t *scp, cm_scache_t *dscp, cm_user_t *userp,
cm_req_t *reqp, cm_scache_t **outScpp)
if (scp->mountRootFid.cell != 0 && scp->mountRootGen >= cm_data.mountRootGen) {
tfid = scp->mountRootFid;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
code = cm_GetSCache(&tfid, outScpp, userp, reqp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
return code;
}
strncpy(cellNamep, mpNamep+1, cp - mpNamep - 1);
strcpy(volNamep, cp+1);
/* now look up the cell */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cellp = cm_GetCell(cellNamep, CM_FLAG_CREATE);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
}
else {
/* normal mt pt */
}
/* now we need to get the volume */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (cm_VolNameIsID(volNamep)) {
code = cm_GetVolumeByID(cellp, atoi(volNamep), userp, reqp,
CM_GETVOL_FLAG_CREATE, &volp);
code = cm_GetVolumeByName(cellp, volNamep, userp, reqp,
CM_GETVOL_FLAG_CREATE, &volp);
}
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code == 0) {
afs_uint32 cell, volume;
scp->mountRootGen = cm_data.mountRootGen;
tfid = scp->mountRootFid;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
code = cm_GetSCache(&tfid, outScpp, userp, reqp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
}
done:
}
/* tscp is now held */
- lock_ObtainMutex(&tscp->mx);
+ lock_ObtainWrite(&tscp->rw);
code = cm_SyncOp(tscp, NULL, userp, reqp, 0,
CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
if (code) {
- lock_ReleaseMutex(&tscp->mx);
+ lock_ReleaseWrite(&tscp->rw);
cm_ReleaseSCache(tscp);
return code;
}
if (code == 0)
code = cm_FollowMountPoint(tscp, dscp, userp, reqp,
&mountedScp);
- lock_ReleaseMutex(&tscp->mx);
+ lock_ReleaseWrite(&tscp->rw);
cm_ReleaseSCache(tscp);
if (code) {
return code;
tscp = mountedScp;
}
else {
- lock_ReleaseMutex(&tscp->mx);
+ lock_ReleaseWrite(&tscp->rw);
}
/* copy back pointer */
/* insert scache in dnlc */
if ( !dnlcHit && !(flags & CM_FLAG_NOMOUNTCHASE) && rock.ExactFound ) {
/* lock the directory entry to prevent racing callback revokes */
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainRead(&dscp->rw);
if ( dscp->cbServerp != NULL && dscp->cbExpires > 0 )
cm_dnlcEnter(dscp, namep, tscp);
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseRead(&dscp->rw);
}
/* and return */
/* make sure we don't screw up the dir status during the merge */
code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
sflags = CM_SCACHESYNC_STOREDATA;
code = cm_SyncOp(dscp, NULL, userp, reqp, 0, sflags);
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
if (code) {
cm_EndDirOp(&dirop);
return code;
lock_ObtainWrite(&dirop.scp->dirlock);
dirop.lockType = CM_DIRLOCK_WRITE;
}
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
cm_dnlcRemove(dscp, namep);
cm_SyncOpDone(dscp, NULL, sflags);
if (code == 0) {
*/
dscp->cbServerp = NULL;
}
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
if (code == 0 && cm_CheckDirOpForSingleChange(&dirop)) {
cm_DirDeleteEntry(&dirop, namep);
return code;
}
-/* called with a locked vnode, and fills in the link info.
- * returns this the vnode still locked.
+/* called with a write locked vnode, and fills in the link info.
+ * returns this the vnode still write locked.
*/
long cm_HandleLink(cm_scache_t *linkScp, cm_user_t *userp, cm_req_t *reqp)
{
long temp;
osi_hyper_t thyper;
- lock_AssertMutex(&linkScp->mx);
+ lock_AssertWrite(&linkScp->rw);
if (!linkScp->mountPointStringp[0]) {
/* read the link data */
- lock_ReleaseMutex(&linkScp->mx);
+ lock_ReleaseWrite(&linkScp->rw);
thyper.LowPart = thyper.HighPart = 0;
code = buf_Get(linkScp, &thyper, &bufp);
- lock_ObtainMutex(&linkScp->mx);
+ lock_ObtainWrite(&linkScp->rw);
if (code)
return code;
while (1) {
*newRootScpp = NULL;
*newSpaceBufferp = NULL;
- lock_ObtainMutex(&linkScp->mx);
+ lock_ObtainWrite(&linkScp->rw);
code = cm_HandleLink(linkScp, userp, reqp);
if (code)
goto done;
}
done:
- lock_ReleaseMutex(&linkScp->mx);
+ lock_ReleaseWrite(&linkScp->rw);
return code;
}
#ifdef DEBUG_REFCOUNT
/* now, if tscp is a symlink, we should follow
* it and assemble the path again.
*/
- lock_ObtainMutex(&tscp->mx);
+ lock_ObtainWrite(&tscp->rw);
code = cm_SyncOp(tscp, NULL, userp, reqp, 0,
CM_SCACHESYNC_GETSTATUS
| CM_SCACHESYNC_NEEDCALLBACK);
if (code) {
- lock_ReleaseMutex(&tscp->mx);
+ lock_ReleaseWrite(&tscp->rw);
cm_ReleaseSCache(tscp);
tscp = NULL;
if (dirScp) {
if (tscp->fileType == CM_SCACHETYPE_SYMLINK) {
/* this is a symlink; assemble a new buffer */
- lock_ReleaseMutex(&tscp->mx);
+ lock_ReleaseWrite(&tscp->rw);
if (symlinkCount++ >= MAX_SYMLINK_COUNT) {
cm_ReleaseSCache(tscp);
tscp = NULL;
}
} else {
/* not a symlink, we may be done */
- lock_ReleaseMutex(&tscp->mx);
+ lock_ReleaseWrite(&tscp->rw);
if (tc == 0) {
if (phase == 1) {
phase = 2;
cm_SetFid(&tfid, scp->fid.cell, scp->fid.volume, ntohl(dep->fid.vnode), ntohl(dep->fid.unique));
tscp = cm_FindSCache(&tfid);
if (tscp) {
- if (lock_TryMutex(&tscp->mx)) {
+ if (lock_TryWrite(&tscp->rw)) {
/* we have an entry that we can look at */
if (!(tscp->flags & CM_SCACHEFLAG_EACCESS) && cm_HaveCallback(tscp)) {
/* we have a callback on it. Don't bother
* fetching this stat entry, since we're happy
* with the info we have.
*/
- lock_ReleaseMutex(&tscp->mx);
+ lock_ReleaseWrite(&tscp->rw);
cm_ReleaseSCache(tscp);
return 0;
}
- lock_ReleaseMutex(&tscp->mx);
+ lock_ReleaseWrite(&tscp->rw);
} /* got lock */
cm_ReleaseSCache(tscp);
} /* found entry */
return 0;
}
-/* called with a locked scp and a pointer to a buffer. Make bulk stat
+/* called with a write locked scp and a pointer to a buffer. Make bulk stat
* calls on all undeleted files in the page of the directory specified.
*/
afs_int32
memset(&bb, 0, sizeof(bb));
bb.bufOffset = *offsetp;
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
/* first, assemble the file IDs we need to stat */
code = cm_ApplyDir(dscp, cm_TryBulkProc, (void *) &bb, offsetp, userp, reqp, NULL);
/* if we failed, bail out early */
if (code && code != CM_ERROR_STOPNOW) {
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
return code;
}
/* otherwise, if this entry has no callback info,
* merge in this.
*/
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
/* now, we have to be extra paranoid on merging in this
* information, since we didn't use cm_SyncOp before
* starting the fetch to make sure that no bad races
CM_CALLBACK_MAINTAINCOUNT);
cm_MergeStatus(dscp, scp, &bb.stats[j], &volSync, userp, 0);
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
} /* all files in the response */
/* now tell it to drop the count,
filex += filesThisCall;
} /* while there are still more files to process */
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
/* If we did the InlineBulk RPC pull out the return code and log it */
if (inlinebulk) {
lock_ObtainWrite(&scp->bufCreateLock);
/* verify that this is a file, not a dir or a symlink */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, reqp, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code)
else
shrinking = 0;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
- /* can't hold scp->mx lock here, since we may wait for a storeback to
+ /* can't hold scp->rw lock here, since we may wait for a storeback to
* finish if the buffer package is cleaning a buffer by storing it to
* the server.
*/
buf_Truncate(scp, userp, reqp, sizep);
/* now ensure that file length is short enough, and update truncPos */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
/* make sure we have a callback (so we have the right value for the
* length), and wait for it to be safe to do a truncate.
| CM_SCACHESYNC_SETSTATUS | CM_SCACHESYNC_SETSIZE);
done:
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ReleaseWrite(&scp->bufCreateLock);
return code;
if (attrp->mask & CM_ATTRMASK_LENGTH)
return cm_SetLength(scp, &attrp->length, userp, reqp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
/* otherwise, we have to make an RPC to get the status */
code = cm_SyncOp(scp, NULL, userp, reqp, 0, CM_SCACHESYNC_STORESTATUS);
if (code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
return code;
}
+ lock_ConvertWToR(&scp->rw);
/* make the attr structure */
cm_StatusFromAttr(&afsInStatus, scp, attrp);
tfid.Volume = scp->fid.volume;
tfid.Vnode = scp->fid.vnode;
tfid.Unique = scp->fid.unique;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseRead(&scp->rw);
/* now make the RPC */
osi_Log1(afsd_logp, "CALL StoreStatus scp 0x%p", scp);
else
osi_Log0(afsd_logp, "CALL StoreStatus SUCCESS");
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_STORESTATUS);
if (code == 0)
cm_MergeStatus(NULL, scp, &afsOutStatus, &volSync, userp,
*/
if (afsInStatus.Mask & AFS_SETMODE)
cm_FreeAllACLEnts(scp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
return code;
}
* completes.
*/
cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
if (code == 0) {
cm_StartCallbackGrantingCall(NULL, &cbReq);
} else {
lock_ObtainWrite(&dirop.scp->dirlock);
dirop.lockType = CM_DIRLOCK_WRITE;
}
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
if (code == 0) {
cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, CM_MERGEFLAG_DIROP);
}
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
/* now try to create the file's entry, too, but be careful to
* make sure that we don't merge in old info. Since we weren't locking
cm_SetFid(&newFid, dscp->fid.cell, dscp->fid.volume, newAFSFid.Vnode, newAFSFid.Unique);
code = cm_GetSCache(&newFid, &scp, userp, reqp);
if (code == 0) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
scp->creator = userp; /* remember who created it */
if (!cm_HaveCallback(scp)) {
cm_MergeStatus(dscp, scp, &newFileStatus, &volSync,
&newFileCallback, 0);
didEnd = 1;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
*scpp = scp;
}
}
code = buf_CleanVnode(scp, userp, reqp);
if (code == 0) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (scp->mask & (CM_SCACHEMASK_TRUNCPOS
| CM_SCACHEMASK_CLIENTMODTIME
scp->flags &= ~(CM_SCACHEFLAG_OVERQUOTA | CM_SCACHEFLAG_OUTOFSPACE);
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
}
return code;
}
* our call completes.
*/
cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
if (code == 0) {
cm_StartCallbackGrantingCall(NULL, &cbReq);
} else {
lock_ObtainWrite(&dirop.scp->dirlock);
dirop.lockType = CM_DIRLOCK_WRITE;
}
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
if (code == 0) {
cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, CM_MERGEFLAG_DIROP);
}
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
/* now try to create the new dir's entry, too, but be careful to
* make sure that we don't merge in old info. Since we weren't locking
cm_SetFid(&newFid, dscp->fid.cell, dscp->fid.volume, newAFSFid.Vnode, newAFSFid.Unique);
code = cm_GetSCache(&newFid, &scp, userp, reqp);
if (code == 0) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (!cm_HaveCallback(scp)) {
cm_MergeStatus(dscp, scp, &newDirStatus, &volSync,
userp, 0);
&newDirCallback, 0);
didEnd = 1;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
}
}
}
cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
if (code != 0)
cm_EndDirOp(&dirop);
lock_ObtainWrite(&dirop.scp->dirlock);
dirop.lockType = CM_DIRLOCK_WRITE;
}
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
if (code == 0) {
cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, CM_MERGEFLAG_DIROP);
}
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
if (code == 0) {
if (cm_CheckDirOpForSingleChange(&dirop)) {
* call completes.
*/
cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
if (code != 0)
cm_EndDirOp(&dirop);
if (code) {
lock_ObtainWrite(&dirop.scp->dirlock);
dirop.lockType = CM_DIRLOCK_WRITE;
}
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
if (code == 0) {
cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, CM_MERGEFLAG_DIROP);
}
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
if (code == 0) {
if (cm_CheckDirOpForSingleChange(&dirop)) {
cm_SetFid(&newFid, dscp->fid.cell, dscp->fid.volume, newAFSFid.Vnode, newAFSFid.Unique);
code = cm_GetSCache(&newFid, &scp, userp, reqp);
if (code == 0) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (!cm_HaveCallback(scp)) {
cm_MergeStatus(dscp, scp, &newLinkStatus, &volSync,
userp, 0);
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
}
}
* call completes.
*/
cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
if (code) {
cm_EndDirOp(&dirop);
return code;
lock_ObtainWrite(&dirop.scp->dirlock);
dirop.lockType = CM_DIRLOCK_WRITE;
}
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
if (code == 0) {
cm_dnlcRemove(dscp, namep);
cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, CM_MERGEFLAG_DIROP);
}
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
if (code == 0) {
if (cm_CheckDirOpForSingleChange(&dirop)) {
long cm_Open(cm_scache_t *scp, int type, cm_user_t *userp)
{
/* grab mutex on contents */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
/* reset the prefetch info */
scp->prefetch.base.LowPart = 0; /* base */
scp->prefetch.end.HighPart = 0;
/* release mutex on contents */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
/* we're done */
return 0;
oneDir = 1;
cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_NONE, &oldDirOp);
- lock_ObtainMutex(&oldDscp->mx);
+ lock_ObtainWrite(&oldDscp->rw);
cm_dnlcRemove(oldDscp, oldNamep);
cm_dnlcRemove(oldDscp, newNamep);
code = cm_SyncOp(oldDscp, NULL, userp, reqp, 0,
CM_SCACHESYNC_STOREDATA);
- lock_ReleaseMutex(&oldDscp->mx);
+ lock_ReleaseWrite(&oldDscp->rw);
if (code != 0) {
cm_EndDirOp(&oldDirOp);
}
if (oldDscp->fid.vnode < newDscp->fid.vnode) {
cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_NONE, &oldDirOp);
- lock_ObtainMutex(&oldDscp->mx);
+ lock_ObtainWrite(&oldDscp->rw);
cm_dnlcRemove(oldDscp, oldNamep);
code = cm_SyncOp(oldDscp, NULL, userp, reqp, 0,
CM_SCACHESYNC_STOREDATA);
- lock_ReleaseMutex(&oldDscp->mx);
+ lock_ReleaseWrite(&oldDscp->rw);
if (code != 0)
cm_EndDirOp(&oldDirOp);
if (code == 0) {
cm_BeginDirOp(newDscp, userp, reqp, CM_DIRLOCK_NONE, &newDirOp);
- lock_ObtainMutex(&newDscp->mx);
+ lock_ObtainWrite(&newDscp->rw);
cm_dnlcRemove(newDscp, newNamep);
code = cm_SyncOp(newDscp, NULL, userp, reqp, 0,
CM_SCACHESYNC_STOREDATA);
- lock_ReleaseMutex(&newDscp->mx);
+ lock_ReleaseWrite(&newDscp->rw);
if (code) {
cm_EndDirOp(&newDirOp);
/* cleanup first one */
- lock_ObtainMutex(&oldDscp->mx);
+ lock_ObtainWrite(&oldDscp->rw);
cm_SyncOpDone(oldDscp, NULL,
CM_SCACHESYNC_STOREDATA);
- lock_ReleaseMutex(&oldDscp->mx);
+ lock_ReleaseWrite(&oldDscp->rw);
cm_EndDirOp(&oldDirOp);
}
}
else {
/* lock the new vnode entry first */
cm_BeginDirOp(newDscp, userp, reqp, CM_DIRLOCK_NONE, &newDirOp);
- lock_ObtainMutex(&newDscp->mx);
+ lock_ObtainWrite(&newDscp->rw);
cm_dnlcRemove(newDscp, newNamep);
code = cm_SyncOp(newDscp, NULL, userp, reqp, 0,
CM_SCACHESYNC_STOREDATA);
- lock_ReleaseMutex(&newDscp->mx);
+ lock_ReleaseWrite(&newDscp->rw);
if (code != 0)
cm_EndDirOp(&newDirOp);
if (code == 0) {
cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_NONE, &oldDirOp);
- lock_ObtainMutex(&oldDscp->mx);
+ lock_ObtainWrite(&oldDscp->rw);
cm_dnlcRemove(oldDscp, oldNamep);
code = cm_SyncOp(oldDscp, NULL, userp, reqp, 0,
CM_SCACHESYNC_STOREDATA);
- lock_ReleaseMutex(&oldDscp->mx);
+ lock_ReleaseWrite(&oldDscp->rw);
if (code != 0)
cm_EndDirOp(&oldDirOp);
if (code) {
/* cleanup first one */
- lock_ObtainMutex(&newDscp->mx);
+ lock_ObtainWrite(&newDscp->rw);
cm_SyncOpDone(newDscp, NULL,
CM_SCACHESYNC_STOREDATA);
- lock_ReleaseMutex(&newDscp->mx);
+ lock_ReleaseWrite(&newDscp->rw);
cm_EndDirOp(&newDirOp);
}
}
lock_ObtainWrite(&oldDirOp.scp->dirlock);
oldDirOp.lockType = CM_DIRLOCK_WRITE;
}
- lock_ObtainMutex(&oldDscp->mx);
+ lock_ObtainWrite(&oldDscp->rw);
cm_SyncOpDone(oldDscp, NULL, CM_SCACHESYNC_STOREDATA);
if (code == 0)
cm_MergeStatus(NULL, oldDscp, &updatedOldDirStatus, &volSync,
userp, CM_MERGEFLAG_DIROP);
- lock_ReleaseMutex(&oldDscp->mx);
+ lock_ReleaseWrite(&oldDscp->rw);
if (code == 0) {
if (cm_CheckDirOpForSingleChange(&oldDirOp)) {
lock_ObtainWrite(&newDirOp.scp->dirlock);
newDirOp.lockType = CM_DIRLOCK_WRITE;
}
- lock_ObtainMutex(&newDscp->mx);
+ lock_ObtainWrite(&newDscp->rw);
cm_SyncOpDone(newDscp, NULL, CM_SCACHESYNC_STOREDATA);
if (code == 0)
cm_MergeStatus(NULL, newDscp, &updatedNewDirStatus, &volSync,
userp, CM_MERGEFLAG_DIROP);
- lock_ReleaseMutex(&newDscp->mx);
+ lock_ReleaseWrite(&newDscp->rw);
if (code == 0) {
/* we only make the local change if we successfully made
}
}
-/* Called with scp->mx held. Returns 0 if all is clear to read the
+/* Called with scp->rw held. Returns 0 if all is clear to read the
specified range by the client identified by key.
*/
long cm_LockCheckRead(cm_scache_t *scp,
#endif
}
-/* Called with scp->mx held. Returns 0 if all is clear to write the
+/* Called with scp->rw held. Returns 0 if all is clear to write the
specified range by the client identified by key.
*/
long cm_LockCheckWrite(cm_scache_t *scp,
osi_QAdd(&cm_freeFileLocks, &l->q);
}
-/* called with scp->mx held. May release it during processing, but
+/* called with scp->rw held. May release it during processing, but
leaves it held on exit. */
long cm_IntSetLock(cm_scache_t * scp, cm_user_t * userp, int lockType,
cm_req_t * reqp) {
osi_Log2(afsd_logp, "CALL SetLock scp 0x%p for lock %d", scp, lockType);
reqp->flags |= CM_REQ_NORETRY;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
do {
code = cm_ConnFromFID(&cfid, userp, reqp, &connp);
osi_Log0(afsd_logp, "CALL SetLock SUCCESS");
}
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
reqp->flags = reqflags;
return code;
}
-/* called with scp->mx held. Releases it during processing */
+/* called with scp->rw held. Releases it during processing */
long cm_IntReleaseLock(cm_scache_t * scp, cm_user_t * userp,
cm_req_t * reqp) {
long code = 0;
tfid.Unique = scp->fid.unique;
cfid = scp->fid;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
osi_Log1(afsd_logp, "CALL ReleaseLock scp 0x%p", scp);
osi_Log0(afsd_logp,
"CALL ReleaseLock SUCCESS");
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
return code;
}
-/* called with scp->mx held. May release it during processing, but
+/* called with scp->rw held. May release it during processing, but
will exit with lock held.
This will return:
return code;
}
-/* called with scp->mx held */
+/* called with scp->rw held */
long cm_Lock(cm_scache_t *scp, unsigned char sLockType,
LARGE_INTEGER LOffset, LARGE_INTEGER LLength,
cm_key_t key,
static int cm_KeyEquals(cm_key_t k1, cm_key_t k2, int flags);
-/* Called with scp->mx held */
+/* Called with scp->rw held */
long cm_UnlockByKey(cm_scache_t * scp,
cm_key_t key,
int flags,
return code;
}
-/* called with scp->mx held */
+/* called with scp->rw held */
void cm_LockMarkSCacheLost(cm_scache_t * scp)
{
cm_file_lock_t *fileLock;
osi_Log1(afsd_logp, "cm_CheckLocks Updating scp 0x%x", scp);
lock_ReleaseWrite(&cm_scacheLock);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
/* did the lock change while we weren't holding the lock? */
if (!IS_LOCK_ACTIVE(fileLock))
goto post_syncopdone;
}
- /* cm_SyncOp releases scp->mx during which the lock
+ /* cm_SyncOp releases scp->rw during which the lock
may get released. */
if (!IS_LOCK_ACTIVE(fileLock))
goto pre_syncopdone;
scp,
(int) scp->serverLock);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
do {
code = cm_ConnFromFID(&cfid, userp,
code = cm_MapRPCError(code, &req);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code) {
osi_Log1(afsd_logp, "CALL ExtendLock FAILURE, code 0x%x", code);
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_LOCK);
post_syncopdone:
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ObtainWrite(&cm_scacheLock);
osi_Log1(afsd_logp, "cm_CheckLocks completes lock check cycle %d", cm_lockRefreshCycle);
}
-/* NOT called with scp->mx held. */
+/* NOT called with scp->rw held. */
long cm_RetryLock(cm_file_lock_t *oldFileLock, int client_is_dead)
{
long code = 0;
osi_assertx(scp != NULL, "null cm_scache_t");
lock_ReleaseRead(&cm_scacheLock);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_LockCheckPerms(scp, oldFileLock->lockType,
oldFileLock->userp,
}
code = 0;
} else if (code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
return code;
}
}
lock_ReleaseWrite(&cm_scacheLock);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
return 0;
}
if (code != 0) {
lock_ReleaseWrite(&cm_scacheLock);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
goto handleCode;
}
}
lock_ReleaseWrite(&cm_scacheLock);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
return 0;
osi_QRemoveHT(&scp->fileLocksH, &scp->fileLocksT, &oldFileLock->fileq);
lock_ReleaseWrite(&cm_scacheLock);
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
updateLock:
lock_ObtainWrite(&cm_scacheLock);
{
for ( scp = cm_data.scacheHashTablep[i]; scp; scp = scp->nextp ) {
while (scp->fileLocksH != NULL) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
lock_ObtainWrite(&cm_scacheLock);
if (!scp->fileLocksH) {
lock_ReleaseWrite(&cm_scacheLock);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
break;
}
fileLock = (cm_file_lock_t *)((char *) scp->fileLocksH - offsetof(cm_file_lock_t, fileq));
cm_UnlockByKey(scp, key, 0, userp, &req);
cm_ReleaseSCache(scp);
cm_ReleaseUser(userp);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
}
}
}
if (code)
goto done;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL,cm_rootUserp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
goto done;
}
*volID = scp->fid.volume;
*pstatus = cm_GetVolumeStatus(scp->volp, scp->fid.volume);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
done:
if (code)
goto done;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, cm_rootUserp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
goto done;
}
goto done;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
done:
&& !(scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID)
#endif
) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
scp->mountPointStringp[0] = '\0';
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
}
}
lock_ReleaseRead(&cm_volumeLock);
if (cm_GetSCache(&fid, &scp, cm_rootUserp, &req) == 0) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_GetCallback(scp, cm_rootUserp, &req, 1);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
}
lock_ObtainRead(&cm_volumeLock);
bufferp = NULL;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
/* start by looking up the file's end */
code = cm_SyncOp(scp, NULL, userp, &req, 0,
buf_Release(bufferp);
bufferp = NULL;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
code = buf_Get(scp, &thyper, &bufferp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code) goto done;
bufferOffset = thyper;
} /* while 1 */
done:
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
//lock_ReleaseMutex(&fidp->mx);
if (bufferp)
buf_Release(bufferp);
bufferp = NULL;
doWriteBack = 0;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
/* start by looking up the file's end */
code = cm_SyncOp(scp, NULL, userp, &req, 0,
buf_Release(bufferp);
bufferp = NULL;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
code = buf_Get(scp, &thyper, &bufferp);
lock_ObtainMutex(&bufferp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code)
goto done;
lock_ReleaseMutex(&bufferp->mx);
code = cm_GetBuffer(scp, bufferp, NULL, userp,
&req);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ObtainMutex(&bufferp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code)
break;
}
} /* while 1 */
done:
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (bufferp) {
lock_ReleaseMutex(&bufferp->mx);
buf_Release(bufferp);
}
if (code == 0 && doWriteBack) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
cm_SyncOp(scp, NULL, userp, &req, 0, CM_SCACHESYNC_ASYNCSTORE);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_QueueBKGRequest(scp, cm_BkgStore, writeBackOffset.LowPart,
writeBackOffset.HighPart, cm_chunkSize, 0, userp);
}
fidp->vcp = NULL;
scp = fidp->scp; /* release after lock is released */
if (scp) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
scp->flags &= ~CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
osi_Log2(smb_logp,"smb_ReleaseFID fidp 0x%p scp 0x%p", fidp, scp);
fidp->scp = NULL;
}
dsp->cookie, dsp, dsp->scp);
dsp->flags |= SMB_DIRSEARCH_DELETE;
if (dsp->scp != NULL) {
- lock_ObtainMutex(&dsp->scp->mx);
+ lock_ObtainWrite(&dsp->scp->rw);
if (dsp->flags & SMB_DIRSEARCH_BULKST) {
dsp->flags &= ~SMB_DIRSEARCH_BULKST;
dsp->scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
dsp->scp->bulkStatProgress = hzero;
}
- lock_ReleaseMutex(&dsp->scp->mx);
+ lock_ReleaseWrite(&dsp->scp->rw);
}
lock_ReleaseMutex(&dsp->mx);
lock_ReleaseWrite(&smb_globalLock);
LLength.HighPart = 0;
LLength.LowPart = count;
- lock_ObtainMutex(&fidp->scp->mx);
+ lock_ObtainWrite(&fidp->scp->rw);
code = cm_LockCheckRead(fidp->scp, LOffset, LLength, key);
- lock_ReleaseMutex(&fidp->scp->mx);
+ lock_ReleaseWrite(&fidp->scp->rw);
}
if (code) {
goto send1a;
cm_InitReq(&req);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
for (wl = wlRequest->locks; wl; wl = wlNext) {
wlNext = (smb_waitingLock_t *) osi_QNext(&wl->q);
free(wl);
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
} else {
*dptr++ = SMB_ATTR_HIDDEN;
continue;
}
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, reqp, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
if (patchp->flags & SMB_DIRLISTPATCH_DOTFILE)
*dptr++ = SMB_ATTR_HIDDEN;
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ lock_ConvertWToR(&scp->rw);
attr = smb_Attributes(scp);
/* check hidden attribute (the flag is only ON when dot file hiding is on ) */
if (patchp->flags & SMB_DIRLISTPATCH_DOTFILE)
/* copy out file length */
*((u_long *)dptr) = scp->length.LowPart;
dptr += 4;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseRead(&scp->rw);
cm_ReleaseSCache(scp);
}
* now.
*/
cm_HoldSCache(scp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if ((scp->flags & CM_SCACHEFLAG_BULKSTATTING) == 0
&& LargeIntegerGreaterOrEqualToZero(scp->bulkStatProgress)) {
scp->flags |= CM_SCACHEFLAG_BULKSTATTING;
dsp->flags |= SMB_DIRSEARCH_BULKST;
dsp->scp->bulkStatProgress = hzero;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
}
}
lock_ReleaseMutex(&dsp->mx);
smb_SetSMBParm(outp, 0, 0);
/* get the directory size */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
cm_ReleaseUser(userp);
smb_DeleteDirSearch(dsp);
buf_Release(bufferp);
bufferp = NULL;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
code = buf_Get(scp, &thyper, &bufferp);
lock_ObtainMutex(&dsp->mx);
*/
if (starPattern) {
smb_ApplyDirListPatches(&dirListPatchesp, dsp->tidPath, dsp->relPath, userp, &req);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if ((dsp->flags & SMB_DIRSEARCH_BULKST) &&
LargeIntegerGreaterThanOrEqualTo(thyper,
scp->bulkStatProgress)) {
code = cm_TryBulkStat(scp, &thyper, userp, &req);
}
} else {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
}
lock_ReleaseMutex(&dsp->mx);
if (code) {
} /* while copying data for dir listing */
/* release the mutex */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (bufferp) {
buf_Release(bufferp);
bufferp = NULL;
#endif /* DFS_SUPPORT */
/* now lock the vnode with a callback; returns with newScp locked */
- lock_ObtainMutex(&newScp->mx);
+ lock_ObtainWrite(&newScp->rw);
code = cm_SyncOp(newScp, NULL, userp, &req, PRSFS_LOOKUP,
CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
if (code) {
if (code != CM_ERROR_NOACCESS) {
- lock_ReleaseMutex(&newScp->mx);
+ lock_ReleaseWrite(&newScp->rw);
cm_ReleaseSCache(newScp);
cm_ReleaseUser(userp);
return code;
if (!(attrs & SMB_ATTR_DIRECTORY))
code = CM_ERROR_NOTDIR;
- lock_ReleaseMutex(&newScp->mx);
+ lock_ReleaseWrite(&newScp->rw);
cm_ReleaseSCache(newScp);
cm_ReleaseUser(userp);
* need the current status to determine what the new status is, in some
* cases.
*/
- lock_ObtainMutex(&newScp->mx);
+ lock_ObtainWrite(&newScp->rw);
code = cm_SyncOp(newScp, NULL, userp, &req, 0,
CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
if (code) {
- lock_ReleaseMutex(&newScp->mx);
+ lock_ReleaseWrite(&newScp->rw);
cm_ReleaseSCache(newScp);
cm_ReleaseUser(userp);
return code;
/* Check for RO volume */
if (newScp->flags & CM_SCACHEFLAG_RO) {
- lock_ReleaseMutex(&newScp->mx);
+ lock_ReleaseWrite(&newScp->rw);
cm_ReleaseSCache(newScp);
cm_ReleaseUser(userp);
return CM_ERROR_READONLY;
attr.unixModeBits = newScp->unixModeBits | 0222;
attr.mask |= CM_ATTRMASK_UNIXMODEBITS;
}
- lock_ReleaseMutex(&newScp->mx);
+ lock_ReleaseWrite(&newScp->rw);
/* now call setattr */
if (attr.mask)
#endif /* DFS_SUPPORT */
/* now lock the vnode with a callback; returns with newScp locked */
- lock_ObtainMutex(&newScp->mx);
+ lock_ObtainWrite(&newScp->rw);
code = cm_SyncOp(newScp, NULL, userp, &req, 0,
CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
if (code) {
- lock_ReleaseMutex(&newScp->mx);
+ lock_ReleaseWrite(&newScp->rw);
cm_ReleaseSCache(newScp);
cm_ReleaseUser(userp);
return code;
smb_SetSMBParm(outp, 8, 0);
smb_SetSMBParm(outp, 9, 0);
smb_SetSMBDataLength(outp, 0);
- lock_ReleaseMutex(&newScp->mx);
+ lock_ReleaseWrite(&newScp->rw);
cm_ReleaseSCache(newScp);
cm_ReleaseUser(userp);
/* save a pointer to the vnode */
fidp->scp = scp;
osi_Log2(smb_logp,"smb_ReceiveCoreOpen fidp 0x%p scp 0x%p", fidp, scp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
scp->flags |= CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
/* and the user */
cm_HoldUser(userp);
fidp->flags |= (SMB_FID_OPENREAD_LISTDIR | SMB_FID_OPENWRITE);
lock_ReleaseMutex(&fidp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainRead(&scp->rw);
smb_SetSMBParm(outp, 0, fidp->fid);
smb_SetSMBParm(outp, 1, smb_Attributes(scp));
smb_DosUTimeFromUnixTime(&dosTime, scp->clientModTime);
/* pass the open mode back; XXXX add access checks */
smb_SetSMBParm(outp, 6, (share & 0xf));
smb_SetSMBDataLength(outp, 0);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseRead(&scp->rw);
/* notify open */
cm_Open(scp, 0, userp);
/* CM_UNLOCK_BY_FID doesn't look at the process ID. We pass
in zero. */
key = cm_GenerateKey(vcp->vcID, 0, fidp->fid);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
tcode = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK
post_syncopdone:
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ObtainMutex(&fidp->mx);
}
if (delscp) {
if (deleted) {
- lock_ObtainMutex(&delscp->mx);
+ lock_ObtainWrite(&delscp->rw);
if (deleted)
delscp->flags |= CM_SCACHEFLAG_DELETED;
- lock_ReleaseMutex(&delscp->mx);
+ lock_ReleaseWrite(&delscp->rw);
}
cm_ReleaseSCache(delscp);
}
if (scp) {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (nullcreator && scp->creator == userp)
scp->creator = NULL;
scp->flags &= ~CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
}
lock_ObtainMutex(&fidp->mx);
scp = fidp->scp;
cm_HoldSCache(scp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (offset.HighPart == 0) {
chunk = offset.LowPart >> cm_logChunkSize;
buf_Release(bufferp);
bufferp = NULL;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
code = buf_Get(scp, &thyper, &bufferp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code) goto done;
bufferOffset = thyper;
} /* while 1 */
done:
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (bufferp)
buf_Release(bufferp);
cm_HoldSCache(scp);
lock_ReleaseMutex(&fidp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
/* start by looking up the file's end */
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK
buf_Release(bufferp);
bufferp = NULL;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
code = buf_Get(scp, &thyper, &bufferp);
lock_ObtainMutex(&bufferp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code) goto done;
bufferOffset = thyper;
lock_ReleaseMutex(&bufferp->mx);
code = cm_GetBuffer(scp, bufferp, NULL, userp,
&req);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ObtainMutex(&bufferp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (code) break;
}
if (code) {
} /* while 1 */
done:
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (bufferp) {
lock_ReleaseMutex(&bufferp->mx);
if (doWriteBack) {
long code2;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
osi_Log1(smb_logp, "smb_WriteData fid %d calling cm_SyncOp ASYNCSTORE",
fidp->fid);
code2 = cm_SyncOp(scp, NULL, userp, &req, 0, CM_SCACHESYNC_ASYNCSTORE);
osi_Log2(smb_logp, "smb_WriteData fid %d calling cm_SyncOp ASYNCSTORE returns 0x%x",
fidp->fid, code2);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_QueueBKGRequest(scp, cm_BkgStore, writeBackOffset.LowPart,
writeBackOffset.HighPart,
smb_AsyncStoreSize, 0, userp);
LLength.HighPart = 0;
LLength.LowPart = count;
- lock_ObtainMutex(&fidp->scp->mx);
+ lock_ObtainWrite(&fidp->scp->rw);
code = cm_LockCheckWrite(fidp->scp, LOffset, LLength, key);
- lock_ReleaseMutex(&fidp->scp->mx);
+ lock_ReleaseWrite(&fidp->scp->rw);
if (code) {
osi_Log1(smb_logp, "smb_ReceiveCoreWrite lock check failure 0x%x", code);
LLength.HighPart = 0;
LLength.LowPart = count;
- lock_ObtainMutex(&fidp->scp->mx);
+ lock_ObtainWrite(&fidp->scp->rw);
code = cm_LockCheckWrite(fidp->scp, LOffset, LLength, key);
- lock_ReleaseMutex(&fidp->scp->mx);
+ lock_ReleaseWrite(&fidp->scp->rw);
if (code) {
smb_ReleaseFID(fidp);
LLength.HighPart = 0;
LLength.LowPart = count;
- lock_ObtainMutex(&fidp->scp->mx);
+ lock_ObtainWrite(&fidp->scp->rw);
code = cm_LockCheckRead(fidp->scp, LOffset, LLength, key);
- lock_ReleaseMutex(&fidp->scp->mx);
+ lock_ReleaseWrite(&fidp->scp->rw);
}
if (code) {
smb_ReleaseFID(fidp);
/* save a pointer to the vnode */
fidp->scp = scp;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
scp->flags |= CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
/* and the user */
fidp->userp = userp;
scp = fidp->scp;
cm_HoldSCache(scp);
lock_ReleaseMutex(&fidp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code == 0) {
smb_SetSMBParm(outp, 1, (new_offset.LowPart>>16) & 0xffff);
smb_SetSMBDataLength(outp, 0);
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
smb_ReleaseFID(fidp);
cm_ReleaseSCache(scp);
cm_ReleaseUser(userp);
if (fidp->scp != NULL) {
scp = fidp->scp;
fidp->scp = NULL;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
scp->flags &= ~CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
osi_Log2(smb_logp,"smb_Shutdown fidp 0x%p scp 0x%p", fidp, scp);
cm_ReleaseSCache(scp);
}
/* save a pointer to the vnode */
osi_Log2(smb_logp,"smb_ReceiveTran2Open fidp 0x%p scp 0x%p", fidp, scp);
fidp->scp = scp;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
scp->flags |= CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
/* and the user */
fidp->userp = userp;
/* copy out remainder of the parms */
parmSlot = 0;
outp->parmsp[parmSlot++] = fidp->fid;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainRead(&scp->rw);
if (extraInfo) {
outp->parmsp[parmSlot++] = smb_Attributes(scp);
smb_SearchTimeFromUnixTime(&dosTime, scp->clientModTime);
outp->parmsp[parmSlot++] = 0;
outp->parmsp[parmSlot++] = 0;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseRead(&scp->rw);
outp->totalData = 0; /* total # of data bytes */
outp->totalParms = parmSlot * 2; /* shorts are two bytes */
}
#endif /* DFS_SUPPORT */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
scp_mx_held = 1;
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ lock_ConvertWToR(&scp->rw);
+
/* now we have the status in the cache entry, and everything is locked.
* Marshall the output data.
*/
qpi.u.QPfileStandardInfo.reserved = 0;
if (fidp) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseRead(&scp->rw);
scp_mx_held = 0;
lock_ObtainMutex(&fidp->mx);
delonclose = fidp->flags & SMB_FID_DELONCLOSE;
/* send and free the packets */
done:
if (scp_mx_held)
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseRead(&scp->rw);
cm_ReleaseSCache(scp);
cm_ReleaseUser(userp);
if (code == 0) {
/* lock the vnode with a callback; we need the current status
* to determine what the new status is, in some cases.
*/
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_GETSTATUS
| CM_SCACHESYNC_NEEDCALLBACK);
if (code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
goto done;
}
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ObtainMutex(&fidp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainRead(&scp->rw);
/* prepare for setattr call */
attr.mask = CM_ATTRMASK_LENGTH;
attr.unixModeBits = scp->unixModeBits | 0222;
}
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseRead(&scp->rw);
lock_ReleaseMutex(&fidp->mx);
/* call setattr */
cm_scache_t *scp;
smb_tran2QFileInfo_t qfi;
long code = 0;
+ int readlock = 0;
cm_req_t req;
cm_InitReq(&req);
osi_Log2(smb_logp,"smb_ReleaseTran2QFileInfo fidp 0x%p scp 0x%p", fidp, scp);
cm_HoldSCache(scp);
lock_ReleaseMutex(&fidp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code)
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ lock_ConvertWToR(&scp->rw);
+ readlock = 1;
+
/* now we have the status in the cache entry, and everything is locked.
* Marshall the output data.
*/
unsigned long len;
char *name;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseRead(&scp->rw);
lock_ObtainMutex(&fidp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainRead(&scp->rw);
if (fidp->NTopen_wholepathp)
name = fidp->NTopen_wholepathp;
else
/* send and free the packets */
done:
- lock_ReleaseMutex(&scp->mx);
+ if (readlock)
+ lock_ReleaseRead(&scp->rw);
+ else
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
cm_ReleaseUser(userp);
smb_ReleaseFID(fidp);
/* lock the vnode with a callback; we need the current status
* to determine what the new status is, in some cases.
*/
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_GETSTATUS
| CM_SCACHESYNC_NEEDCALLBACK);
if (code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
goto done;
}
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
lock_ObtainMutex(&fidp->mx);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainRead(&scp->rw);
/* prepare for setattr call */
attr.mask = 0;
attr.unixModeBits = scp->unixModeBits | 0222;
}
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseRead(&scp->rw);
lock_ReleaseMutex(&fidp->mx);
/* call setattr */
if (code == 0 && !(rights & PRSFS_READ))
mustFake = 1;
else if (code == -1) {
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
code = cm_SyncOp(dscp, NULL, userp, reqp, PRSFS_READ,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
if (code == CM_ERROR_NOACCESS) {
mustFake = 1;
code = 0;
if (code)
continue;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (mustFake == 0)
code = cm_SyncOp(scp, NULL, userp, reqp, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (mustFake || code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
dptr = patchp->dptr;
/* now watch for a symlink */
code = 0;
while (code == 0 && scp->fileType == CM_SCACHETYPE_SYMLINK) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
snprintf(path, AFSPATHMAX, "%s\\%s", relPathp ? relPathp : "", patchp->dep->name);
reqp->relPathp = path;
reqp->tidPathp = tidPathp;
cm_ReleaseSCache(scp);
scp = targetScp;
}
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
}
+ lock_ConvertWToR(&scp->rw);
+
dptr = patchp->dptr;
if (infoLevel >= SMB_FIND_FILE_DIRECTORY_INFO) {
*dptr++ = (attr >> 8) & 0xff;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseRead(&scp->rw);
cm_ReleaseSCache(scp);
}
* and so we do another hold now.
*/
cm_HoldSCache(scp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if ((scp->flags & CM_SCACHEFLAG_BULKSTATTING) == 0 &&
LargeIntegerGreaterOrEqualToZero(scp->bulkStatProgress)) {
scp->flags |= CM_SCACHEFLAG_BULKSTATTING;
dsp->flags |= SMB_DIRSEARCH_BULKST;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
}
}
lock_ReleaseMutex(&dsp->mx);
}
/* get the directory size */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code) {
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
cm_ReleaseUser(userp);
smb_FreeTran2Packet(outp);
buf_Release(bufferp);
bufferp = NULL;
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
code = buf_Get(scp, &thyper, &bufferp);
lock_ObtainMutex(&dsp->mx);
if (starPattern) {
code2 = smb_ApplyV3DirListPatches(scp, &dirListPatchesp, dsp->tidPath, dsp->relPath, infoLevel, userp, &req);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if ((dsp->flags & SMB_DIRSEARCH_BULKST) &&
LargeIntegerGreaterThanOrEqualTo(thyper, scp->bulkStatProgress)) {
/* Don't bulk stat if risking timeout */
code = cm_TryBulkStat(scp, &thyper, userp, &req);
}
} else {
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
}
lock_ReleaseMutex(&dsp->mx);
if (code) {
}
/* release the mutex */
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (bufferp) {
buf_Release(bufferp);
bufferp = NULL;
lock_ObtainMutex(&fidp->mx);
/* save a pointer to the vnode */
fidp->scp = scp;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
scp->flags |= CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
osi_Log2(smb_logp,"smb_ReceiveV3OpenX fidp 0x%p scp 0x%p", fidp, scp);
/* also the user */
fidp->userp = userp;
/* copy out remainder of the parms */
parmSlot = 2;
smb_SetSMBParm(outp, parmSlot, fidp->fid); parmSlot++;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainRead(&scp->rw);
if (extraInfo) {
smb_SetSMBParm(outp, parmSlot, smb_Attributes(scp)); parmSlot++;
smb_DosUTimeFromUnixTime(&dosTime, scp->clientModTime);
smb_SetSMBParm(outp, parmSlot, scp->fid.vnode & 0xffff); parmSlot++;
smb_SetSMBParm(outp, parmSlot, scp->fid.volume & 0xffff); parmSlot++;
smb_SetSMBParm(outp, parmSlot, 0); parmSlot++;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseRead(&scp->rw);
smb_SetSMBDataLength(outp, 0);
osi_Log1(smb_logp, "SMB OpenX opening fid %d", fidp->fid);
userp = smb_GetUserFromVCP(vcp, inp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK
| CM_SCACHESYNC_GETSTATUS
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_LOCK);
doneSync:
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
cm_ReleaseUser(userp);
smb_ReleaseFID(fidp);
afs_uint32 searchTime;
cm_user_t *userp;
cm_req_t req;
+ int readlock = 0;
cm_InitReq(&req);
/* otherwise, stat the file */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code)
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ lock_ConvertWToR(&scp->rw);
+
/* decode times. We need a search time, but the response to this
* call provides the date first, not the time, as returned in the
* searchTime variable. So we take the high-order bits first.
code = 0;
done:
- lock_ReleaseMutex(&scp->mx);
+ if (readlock)
+ lock_ReleaseRead(&scp->rw);
+ else
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
cm_ReleaseUser(userp);
smb_ReleaseFID(fidp);
LLength.LowPart = count;
scp = fidp->scp;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_LockCheckWrite(scp, LOffset, LLength, key);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (code)
goto done;
LLength.LowPart = count;
scp = fidp->scp;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_LockCheckRead(scp, LOffset, LLength, key);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
}
if (code) {
key = cm_GenerateKey(vcp->vcID, SMB_FID_QLOCK_PID, fidp->fid);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_Lock(scp, sLockType, LOffset, LLength, key, 0, userp, &req, NULL);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (code) {
if (ldp)
lock_ObtainMutex(&fidp->mx);
/* save a pointer to the vnode */
fidp->scp = scp; /* Hold transfered to fidp->scp and no longer needed */
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
scp->flags |= CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
osi_Log2(smb_logp,"smb_ReceiveNTCreateX fidp 0x%p scp 0x%p", fidp, scp);
fidp->flags = fidflags;
/* out parms */
parmSlot = 2;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainRead(&scp->rw);
smb_SetSMBParmByte(outp, parmSlot, 0); /* oplock */
smb_SetSMBParm(outp, parmSlot, fidp->fid); parmSlot++;
smb_SetSMBParmLong(outp, parmSlot, openAction); parmSlot += 2;
fidp->scp->length.LowPart, fidp->scp->length.HighPart,
userp);
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseRead(&scp->rw);
osi_Log2(smb_logp, "SMB NT CreateX opening fid %d path %s", fidp->fid,
osi_LogSaveString(smb_logp, realPathp));
key = cm_GenerateKey(vcp->vcID, SMB_FID_QLOCK_PID, fidp->fid);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
code = cm_Lock(scp, sLockType, LOffset, LLength, key, 0, userp, &req, NULL);
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
if (code) {
if (ldp)
lock_ObtainMutex(&fidp->mx);
/* save a pointer to the vnode */
fidp->scp = scp;
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
scp->flags |= CM_SCACHEFLAG_SMB_FID;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
osi_Log2(smb_logp,"smb_ReceiveNTTranCreate fidp 0x%p scp 0x%p", fidp, scp);
fidp->flags = fidflags;
smb_SetSMBParmByte(outp, parmSlot, 0); /* Setup Count */
smb_SetSMBDataLength(outp, 70);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainRead(&scp->rw);
outData = smb_GetSMBData(outp, NULL);
outData++; /* round to get to parmOffset */
*outData = 0; outData++; /* oplock */
scp->fileType == CM_SCACHETYPE_MOUNTPOINT ||
scp->fileType == CM_SCACHETYPE_INVALID) ? 1 : 0);
outData += 2; /* is a dir? */
- lock_ReleaseMutex(&scp->mx);
} else {
/* out parms */
parmOffset = 8*4 + 39;
smb_SetSMBParmByte(outp, parmSlot, 0); /* Setup Count */
smb_SetSMBDataLength(outp, 105);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainRead(&scp->rw);
outData = smb_GetSMBData(outp, NULL);
outData++; /* round to get to parmOffset */
*outData = 0; outData++; /* oplock */
memset(outData,0,24); outData += 24; /* Volume ID and file ID */
*((ULONG *)outData) = 0x001f01ffL; outData += 4; /* Maxmimal access rights */
*((ULONG *)outData) = 0; outData += 4; /* Guest Access rights */
- lock_ReleaseMutex(&scp->mx);
}
- lock_ObtainMutex(&scp->mx);
if ((fidp->flags & SMB_FID_EXECUTABLE) &&
LargeIntegerGreaterThanZero(fidp->scp->length) &&
!(scp->flags & CM_SCACHEFLAG_PREFETCHING)) {
fidp->scp->length.LowPart, fidp->scp->length.HighPart,
userp);
}
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseRead(&scp->rw);
osi_Log1(smb_logp, "SMB NTTranCreate opening fid %d", fidp->fid);
if (filter & FILE_NOTIFY_CHANGE_STREAM_WRITE)
osi_Log0(smb_logp, " Notify Change Stream Write");
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (watchtree)
scp->flags |= CM_SCACHEFLAG_WATCHEDSUBTREE;
else
scp->flags |= CM_SCACHEFLAG_WATCHED;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
smb_ReleaseFID(fidp);
outp->flags |= SMB_PACKETFLAG_NOSEND;
lastWatch->nextp = nextWatch;
/* Turn off WATCHED flag in dscp */
- lock_ObtainMutex(&dscp->mx);
+ lock_ObtainWrite(&dscp->rw);
if (wtree)
dscp->flags &= ~CM_SCACHEFLAG_WATCHEDSUBTREE;
else
dscp->flags &= ~CM_SCACHEFLAG_WATCHED;
- lock_ReleaseMutex(&dscp->mx);
+ lock_ReleaseWrite(&dscp->rw);
/* Convert to response packet */
((smb_t *) watch)->reb = SMB_FLAGS_SERVER_TO_CLIENT;
scp = fidp->scp;
osi_Log2(smb_logp,"smb_ReceiveNTCancel fidp 0x%p scp 0x%p", fidp, scp);
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
if (watchtree)
scp->flags &= ~CM_SCACHEFLAG_WATCHEDSUBTREE;
else
scp->flags &= ~CM_SCACHEFLAG_WATCHED;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
smb_ReleaseFID(fidp);
} else {
osi_Log2(smb_logp,"NTCancel unable to resolve fid [%d] in vcp[%x]", fid,vcp);