From: Jeffrey Altman Date: Mon, 3 Mar 2008 04:25:39 +0000 (+0000) Subject: DEVEL15-windows-scache-mx-to-rw-20080302 X-Git-Tag: openafs-devel-1_5_34~69 X-Git-Url: https://git.michaelhowe.org/gitweb/?a=commitdiff_plain;h=3ee503e2342b287e2c4ecd50adb7370e06a1969d;p=packages%2Fo%2Fopenafs.git DEVEL15-windows-scache-mx-to-rw-20080302 LICENSE MIT Replace the cm_scache_t mutex with a rwlock permitting a small amount of additional parallelization in places where it is safe to use read locks instead of write locks. All functions that eventually call cm_SyncOp must use write locks. (cherry picked from commit 69f9b46e69bb7c8c9356b062a8f4908fe38ad14b) --- diff --git a/src/WINNT/afsd/afsdifs.c b/src/WINNT/afsd/afsdifs.c index 5537325fa..9d8c3df8d 100644 --- a/src/WINNT/afsd/afsdifs.c +++ b/src/WINNT/afsd/afsdifs.c @@ -298,11 +298,7 @@ ifs_CopyInfo(cm_scache_t *scp, ULONG *attribs, LARGE_INTEGER *size, void ifs_InternalClose(cm_scache_t **scpp) { osi_assert(scpp && *scpp); - - lock_ObtainMutex(&((*scpp)->mx)); cm_ReleaseSCache(*scpp); - - lock_ReleaseMutex(&((*scpp)->mx)); *scpp = NULL; } @@ -509,9 +505,9 @@ long uc_check_access(ULONG fid, ULONG access, ULONG *granted) 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) @@ -620,17 +616,17 @@ long uc_stat(ULONG fid, ULONG *attribs, LARGE_INTEGER *size, LARGE_INTEGER *crea /* 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; @@ -662,16 +658,16 @@ long uc_trunc(ULONG fid, LARGE_INTEGER size) */ 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); @@ -860,9 +856,9 @@ ifs_ReaddirCallback(cm_scache_t *scp, cm_dirEntry_t *entry, void *param, osi_hyp } { - 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. */ @@ -870,7 +866,7 @@ ifs_ReaddirCallback(cm_scache_t *scp, cm_dirEntry_t *entry, void *param, osi_hyp 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 */ @@ -879,7 +875,7 @@ ifs_ReaddirCallback(cm_scache_t *scp, cm_dirEntry_t *entry, void *param, osi_hyp 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); @@ -960,9 +956,7 @@ long uc_close(ULONG fid) SCPL_LOCK; /* perhaps this should be earlier */ - lock_ObtainMutex(&(scp->mx)); cm_ReleaseSCache(scp); - lock_ReleaseMutex(&(scp->mx)); prev = NULL, curr = scp_list_head; diff --git a/src/WINNT/afsd/cm_access.c b/src/WINNT/afsd/cm_access.c index b2b2e20be..dc4ce7c00 100644 --- a/src/WINNT/afsd/cm_access.c +++ b/src/WINNT/afsd/cm_access.c @@ -59,7 +59,7 @@ int cm_HaveAccessRights(struct cm_scache *scp, struct cm_user *userp, afs_uint32 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); @@ -69,7 +69,7 @@ int cm_HaveAccessRights(struct cm_scache *scp, struct cm_user *userp, afs_uint32 /* 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; } @@ -78,7 +78,7 @@ int cm_HaveAccessRights(struct cm_scache *scp, struct cm_user *userp, afs_uint32 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, @@ -139,7 +139,7 @@ int cm_HaveAccessRights(struct cm_scache *scp, struct cm_user *userp, afs_uint32 done: if (didLock) - lock_ReleaseMutex(&aclScp->mx); + lock_ReleaseRead(&aclScp->rw); if (release) cm_ReleaseSCache(aclScp); return code; @@ -175,23 +175,23 @@ long cm_GetAccessRights(struct cm_scache *scp, struct cm_user *userp, } 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: diff --git a/src/WINNT/afsd/cm_aclent.c b/src/WINNT/afsd/cm_aclent.c index 2df8b40bb..cc60e9b19 100644 --- a/src/WINNT/afsd/cm_aclent.c +++ b/src/WINNT/afsd/cm_aclent.c @@ -41,7 +41,7 @@ static void CleanupACLEnt(cm_aclent_t * aclp) /* * 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) @@ -129,13 +129,13 @@ static cm_aclent_t *GetFreeACLEnt(cm_scache_t * scp) 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; } diff --git a/src/WINNT/afsd/cm_buf.c b/src/WINNT/afsd/cm_buf.c index e08273ed9..5d8980607 100644 --- a/src/WINNT/afsd/cm_buf.c +++ b/src/WINNT/afsd/cm_buf.c @@ -560,12 +560,12 @@ void buf_WaitIO(cm_scache_t * scp, cm_buf_t *bp) 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); } } @@ -1436,7 +1436,7 @@ long buf_Truncate(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp, 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. @@ -1489,7 +1489,7 @@ long buf_Truncate(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp, 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) { @@ -1601,14 +1601,14 @@ long buf_FlushCleanPages(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp) 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); diff --git a/src/WINNT/afsd/cm_callback.c b/src/WINNT/afsd/cm_callback.c index 418dbb09d..f2a753722 100644 --- a/src/WINNT/afsd/cm_callback.c +++ b/src/WINNT/afsd/cm_callback.c @@ -209,9 +209,9 @@ void cm_RevokeCallback(struct rx_call *callp, cm_cell_t * cellp, AFSFid *fidp) 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); @@ -257,11 +257,11 @@ void cm_RevokeVolumeCallback(struct rx_call *callp, cm_cell_t *cellp, AFSFid *fi 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); @@ -484,7 +484,7 @@ SRXAFSCB_InitCallBackState(struct rx_call *callp) 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 */ @@ -495,7 +495,7 @@ SRXAFSCB_InitCallBackState(struct rx_call *callp) discarded = 1; } } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); if (discarded) cm_CallbackNotifyChange(scp); lock_ObtainWrite(&cm_scacheLock); @@ -761,9 +761,9 @@ SRXAFSCB_GetCE(struct rx_call *callp, long index, AFSDBCacheEntry *cep) 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; @@ -873,9 +873,9 @@ SRXAFSCB_GetCE64(struct rx_call *callp, long index, AFSDBCacheEntry64 *cep) 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; @@ -1559,9 +1559,9 @@ int cm_HaveCallback(cm_scache_t *scp) } 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 @@ -1618,7 +1618,7 @@ void cm_StartCallbackGrantingCall(cm_scache_t *scp, cm_callbackRequest_t *cbrp) /* 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, @@ -1713,9 +1713,9 @@ 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 ) { @@ -1804,7 +1804,7 @@ long cm_GetCallback(cm_scache_t *scp, struct cm_user *userp, } 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", @@ -1829,7 +1829,7 @@ long cm_GetCallback(cm_scache_t *scp, struct cm_user *userp, 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); @@ -1924,9 +1924,9 @@ void cm_CheckCBExpiration(void) 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); diff --git a/src/WINNT/afsd/cm_conn.c b/src/WINNT/afsd/cm_conn.c index ba81e557a..1fe037bfd 100644 --- a/src/WINNT/afsd/cm_conn.c +++ b/src/WINNT/afsd/cm_conn.c @@ -541,20 +541,20 @@ cm_Analyze(cm_conn_t *connp, cm_user_t *userp, cm_req_t *reqp, 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); } diff --git a/src/WINNT/afsd/cm_dcache.c b/src/WINNT/afsd/cm_dcache.c index 93cb73aea..7e329f834 100644 --- a/src/WINNT/afsd/cm_dcache.c +++ b/src/WINNT/afsd/cm_dcache.c @@ -83,9 +83,9 @@ long cm_BufWrite(void *vscp, osi_hyper_t *offsetp, long length, long flags, * 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; } @@ -94,13 +94,13 @@ long cm_BufWrite(void *vscp, osi_hyper_t *offsetp, long length, long flags, 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; } @@ -145,7 +145,7 @@ long cm_BufWrite(void *vscp, osi_hyper_t *offsetp, long length, long flags, require_64bit_ops = 1; } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); /* now we're ready to do the store operation */ do { @@ -262,7 +262,7 @@ long cm_BufWrite(void *vscp, osi_hyper_t *offsetp, long length, long flags, 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); @@ -304,7 +304,7 @@ long cm_BufWrite(void *vscp, osi_hyper_t *offsetp, long length, long flags, 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; @@ -350,7 +350,7 @@ long cm_StoreMini(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp) require_64bit_ops = 1; } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); cm_AFSFidFromFid(&tfid, &scp->fid); @@ -401,7 +401,7 @@ long cm_StoreMini(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp) 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); @@ -442,11 +442,11 @@ long cm_BufStabilize(void *vscp, cm_user_t *userp, cm_req_t *reqp) 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; } @@ -460,7 +460,7 @@ long cm_BufUnstabilize(void *vscp, cm_user_t *userp) 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; @@ -549,14 +549,14 @@ long cm_CheckFetchRange(cm_scache_t *scp, osi_hyper_t *startBasep, osi_hyper_t * 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; } @@ -600,7 +600,7 @@ long cm_CheckFetchRange(cm_scache_t *scp, osi_hyper_t *startBasep, osi_hyper_t * *realBasep = tbase; code = 0; } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); return code; } @@ -632,9 +632,9 @@ cm_BkgStore(cm_scache_t *scp, afs_uint32 p1, afs_uint32 p2, afs_uint32 p3, afs_u 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; } @@ -693,7 +693,7 @@ cm_BkgPrefetch(cm_scache_t *scp, afs_uint32 p1, afs_uint32 p2, afs_uint32 p3, af offset = LargeIntegerAdd(offset, tblocksize) ) { if (mxheld) { - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); mxheld = 0; } @@ -709,7 +709,7 @@ cm_BkgPrefetch(cm_scache_t *scp, afs_uint32 p1, afs_uint32 p2, afs_uint32 p3, af } if (!mxheld) { - lock_ObtainMutex(&scp->mx); + lock_ObtainWrite(&scp->rw); mxheld = 1; } @@ -720,12 +720,12 @@ cm_BkgPrefetch(cm_scache_t *scp, afs_uint32 p1, afs_uint32 p2, afs_uint32 p3, af } 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); @@ -750,10 +750,10 @@ void cm_ConsiderPrefetch(cm_scache_t *scp, osi_hyper_t *offsetp, afs_uint32 coun 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; @@ -764,7 +764,7 @@ void cm_ConsiderPrefetch(cm_scache_t *scp, osi_hyper_t *offsetp, afs_uint32 coun 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); @@ -814,9 +814,9 @@ long cm_SetupStoreBIOD(cm_scache_t *scp, osi_hyper_t *inOffsetp, long inSize, 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) { @@ -826,9 +826,9 @@ long cm_SetupStoreBIOD(cm_scache_t *scp, osi_hyper_t *inOffsetp, long inSize, 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); @@ -902,9 +902,9 @@ long cm_SetupStoreBIOD(cm_scache_t *scp, osi_hyper_t *inOffsetp, long inSize, 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; @@ -962,9 +962,9 @@ long cm_SetupStoreBIOD(cm_scache_t *scp, osi_hyper_t *inOffsetp, long inSize, 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; @@ -1053,7 +1053,7 @@ long cm_SetupFetchBIOD(cm_scache_t *scp, osi_hyper_t *offsetp, /* 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); @@ -1093,7 +1093,7 @@ long cm_SetupFetchBIOD(cm_scache_t *scp, osi_hyper_t *offsetp, 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; } @@ -1158,12 +1158,12 @@ long cm_SetupFetchBIOD(cm_scache_t *scp, osi_hyper_t *offsetp, /* 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; } @@ -1177,7 +1177,7 @@ long cm_SetupFetchBIOD(cm_scache_t *scp, osi_hyper_t *offsetp, */ code = cm_SyncOp(scp, tbp, userp, reqp, 0, flags); if (code) { - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); lock_ReleaseMutex(&tbp->mx); break; } @@ -1185,13 +1185,13 @@ long cm_SetupFetchBIOD(cm_scache_t *scp, osi_hyper_t *offsetp, /* 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 */ @@ -1225,7 +1225,7 @@ long cm_SetupFetchBIOD(cm_scache_t *scp, osi_hyper_t *offsetp, } /* 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 @@ -1279,7 +1279,7 @@ void cm_ReleaseBIOD(cm_bulkIO_t *biop, int isStore, int failed) /* 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 */ @@ -1296,15 +1296,15 @@ void cm_ReleaseBIOD(cm_bulkIO_t *biop, int isStore, int failed) } } - 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 */ @@ -1387,22 +1387,22 @@ long cm_GetBuffer(cm_scache_t *scp, cm_buf_t *bufp, int *cpffp, cm_user_t *userp 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)), @@ -1601,7 +1601,7 @@ long cm_GetBuffer(cm_scache_t *scp, cm_buf_t *bufp, int *cpffp, cm_user_t *userp * 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); @@ -1611,7 +1611,7 @@ long cm_GetBuffer(cm_scache_t *scp, cm_buf_t *bufp, int *cpffp, cm_user_t *userp *cpffp = 1; cm_ClearPrefetchFlag(0, scp, &biod.offset, &tlength); } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); /* and adjust counters */ nbytes -= temp; @@ -1679,7 +1679,7 @@ long cm_GetBuffer(cm_scache_t *scp, cm_buf_t *bufp, int *cpffp, cm_user_t *userp fetchingcompleted: code = cm_MapRPCError(code, reqp); - lock_ObtainMutex(&scp->mx); + lock_ObtainWrite(&scp->rw); cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_FETCHSTATUS); @@ -1706,9 +1706,9 @@ long cm_GetBuffer(cm_scache_t *scp, cm_buf_t *bufp, int *cpffp, cm_user_t *userp } /* 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); diff --git a/src/WINNT/afsd/cm_dir.c b/src/WINNT/afsd/cm_dir.c index f52fb188d..0bf87de8c 100644 --- a/src/WINNT/afsd/cm_dir.c +++ b/src/WINNT/afsd/cm_dir.c @@ -136,10 +136,10 @@ cm_NameEntries(char *namep, long *lenp) 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. @@ -234,10 +234,10 @@ cm_DirCreateEntry(cm_dirOp_t * op, char *entry, cm_fid_t * cfid) /* 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. @@ -271,10 +271,10 @@ cm_DirLength(cm_dirOp_t * op) /* 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. @@ -340,7 +340,7 @@ cm_DirDeleteEntry(cm_dirOp_t * op, char *entry) /* 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) { @@ -444,7 +444,7 @@ 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) @@ -477,7 +477,7 @@ 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) @@ -528,7 +528,7 @@ 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) @@ -577,10 +577,10 @@ 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. @@ -636,10 +636,10 @@ cm_DirLookup(cm_dirOp_t * op, char *entry, cm_fid_t * cfid) /* 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. @@ -694,10 +694,10 @@ cm_DirLookupOffset(cm_dirOp_t * op, char *entry, cm_fid_t *cfid, osi_hyper_t *of /* 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. @@ -749,10 +749,10 @@ cm_DirApply(cm_dirOp_t * op, int (*hookproc) (void *, char *, long, long), void /* 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. @@ -802,15 +802,15 @@ cm_DirIsEmpty(cm_dirOp_t * op) /* 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 @@ -863,10 +863,10 @@ cm_DirHash(char *string) * 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, @@ -959,7 +959,7 @@ 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, @@ -993,7 +993,7 @@ 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) { @@ -1029,14 +1029,14 @@ cm_BeginDirOp(cm_scache_t * scp, cm_user_t * userp, cm_req_t * reqp, 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 && @@ -1051,12 +1051,12 @@ cm_BeginDirOp(cm_scache_t * scp, cm_user_t * userp, cm_req_t * reqp, 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) { @@ -1107,14 +1107,14 @@ cm_BeginDirOp(cm_scache_t * scp, cm_user_t * userp, cm_req_t * reqp, #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); } @@ -1122,7 +1122,7 @@ cm_BeginDirOp(cm_scache_t * scp, cm_user_t * userp, cm_req_t * reqp, } /* 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) { @@ -1132,7 +1132,7 @@ 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 && @@ -1145,7 +1145,7 @@ cm_CheckDirOpForSingleChange(cm_dirOp_t * op) rc = 1; } - lock_ReleaseMutex(&op->scp->mx); + lock_ReleaseWrite(&op->scp->rw); if (rc) osi_Log0(afsd_logp, "cm_CheckDirOpForSingleChange succeeded"); @@ -1157,7 +1157,7 @@ cm_CheckDirOpForSingleChange(cm_dirOp_t * op) } /* 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) { @@ -1193,9 +1193,9 @@ 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) { @@ -1222,7 +1222,7 @@ cm_EndDirOp(cm_dirOp_t * op) 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) { @@ -1261,7 +1261,7 @@ 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); @@ -1283,7 +1283,7 @@ cm_DirOpAddBuffer(cm_dirOp_t * op, cm_buf_t * bufferp) code = CM_ERROR_INVAL; } - lock_ReleaseMutex(&op->scp->mx); + lock_ReleaseWrite(&op->scp->rw); lock_ReleaseMutex(&bufferp->mx); if (code) { @@ -1305,7 +1305,7 @@ cm_DirOpAddBuffer(cm_dirOp_t * op, cm_buf_t * bufferp) } } -/* 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) { @@ -1334,7 +1334,7 @@ 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) { @@ -1366,7 +1366,7 @@ 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 @@ -1383,12 +1383,12 @@ cm_DirOpDelBuffer(cm_dirOp_t * op, cm_buf_t * bufferp, int flags) 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) { @@ -1433,13 +1433,13 @@ cm_DirOpDelBuffer(cm_dirOp_t * op, cm_buf_t * bufferp, int flags) 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) @@ -1447,11 +1447,11 @@ 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); @@ -1463,7 +1463,7 @@ cm_DirCheckStatus(cm_dirOp_t * op, afs_uint32 locked) 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) @@ -1503,15 +1503,15 @@ 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 @@ -1585,14 +1585,14 @@ cm_DirGetPage(cm_dirOp_t * op, 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; } @@ -1602,13 +1602,13 @@ cm_DirGetPage(cm_dirOp_t * op, 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) diff --git a/src/WINNT/afsd/cm_freelance.c b/src/WINNT/afsd/cm_freelance.c index 33a5fabd0..66be4a538 100644 --- a/src/WINNT/afsd/cm_freelance.c +++ b/src/WINNT/afsd/cm_freelance.c @@ -415,9 +415,9 @@ int cm_reInitLocalMountPoints() { // 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); @@ -428,9 +428,9 @@ int cm_reInitLocalMountPoints() { 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; } } diff --git a/src/WINNT/afsd/cm_ioctl.c b/src/WINNT/afsd/cm_ioctl.c index f9a9b3c0c..0e1c4cc5a 100644 --- a/src/WINNT/afsd/cm_ioctl.c +++ b/src/WINNT/afsd/cm_ioctl.c @@ -73,9 +73,9 @@ long cm_CleanFile(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp) 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; @@ -94,10 +94,10 @@ long cm_FlushFile(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp) 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; @@ -164,9 +164,9 @@ void cm_ResetACLCache(cm_user_t *userp) 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); } @@ -754,9 +754,9 @@ long cm_IoctlSetACL(struct smb_ioctl *ioctlp, struct cm_user *userp) 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); @@ -1278,11 +1278,11 @@ long cm_IoctlStatMountPoint(struct smb_ioctl *ioctlp, struct cm_user *userp) 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; } @@ -1294,7 +1294,7 @@ long cm_IoctlStatMountPoint(struct smb_ioctl *ioctlp, struct cm_user *userp) cp += strlen(cp) + 1; ioctlp->outDatap = cp; } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); cm_ReleaseSCache(scp); return code; @@ -1322,25 +1322,25 @@ long cm_IoctlDeleteMountPoint(struct smb_ioctl *ioctlp, struct cm_user *userp) 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 */ @@ -1351,9 +1351,9 @@ long cm_IoctlDeleteMountPoint(struct smb_ioctl *ioctlp, struct cm_user *userp) 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); @@ -2187,7 +2187,7 @@ long cm_IoctlDeletelink(struct smb_ioctl *ioctlp, struct cm_user *userp) 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) @@ -2202,7 +2202,7 @@ long cm_IoctlDeletelink(struct smb_ioctl *ioctlp, struct cm_user *userp) } /* 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); @@ -2212,12 +2212,12 @@ long cm_IoctlDeletelink(struct smb_ioctl *ioctlp, struct cm_user *userp) | 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: diff --git a/src/WINNT/afsd/cm_scache.c b/src/WINNT/afsd/cm_scache.c index 709a4c351..8f97caff6 100644 --- a/src/WINNT/afsd/cm_scache.c +++ b/src/WINNT/afsd/cm_scache.c @@ -320,7 +320,7 @@ cm_scache_t *cm_GetNewSCache(void) "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"); @@ -376,7 +376,7 @@ void cm_fakeSCacheInit(int newFile) 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 @@ -533,9 +533,9 @@ cm_ShutdownSCache(void) 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) { @@ -552,7 +552,7 @@ cm_ShutdownSCache(void) scp->dirDataVersion = -1; lock_FinalizeRWLock(&scp->dirlock); #endif - lock_FinalizeMutex(&scp->mx); + lock_FinalizeRWLock(&scp->rw); lock_FinalizeRWLock(&scp->bufCreateLock); } lock_ReleaseWrite(&cm_scacheLock); @@ -579,7 +579,7 @@ void cm_InitSCache(int newFile, long maxSCaches) 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"); @@ -741,7 +741,7 @@ long cm_GetSCache(cm_fid_t *fidp, cm_scache_t **outScpp, cm_user_t *userp, * 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; @@ -772,7 +772,7 @@ long cm_GetSCache(cm_fid_t *fidp, cm_scache_t **outScpp, cm_user_t *userp, 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); @@ -838,7 +838,7 @@ long cm_GetSCache(cm_fid_t *fidp, cm_scache_t **outScpp, cm_user_t *userp, * 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; @@ -864,7 +864,7 @@ long cm_GetSCache(cm_fid_t *fidp, cm_scache_t **outScpp, cm_user_t *userp, 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 @@ -1233,9 +1233,9 @@ long cm_SyncOp(cm_scache_t *scp, cm_buf_t *bufp, cm_user_t *userp, cm_req_t *req 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; @@ -1260,9 +1260,9 @@ long cm_SyncOp(cm_scache_t *scp, cm_buf_t *bufp, cm_user_t *userp, cm_req_t *req 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; @@ -1303,10 +1303,10 @@ long cm_SyncOp(cm_scache_t *scp, cm_buf_t *bufp, cm_user_t *userp, cm_req_t *req 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(); @@ -1394,7 +1394,7 @@ void cm_SyncOpDone(cm_scache_t *scp, cm_buf_t *bufp, afs_uint32 flags) 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) @@ -1739,7 +1739,7 @@ void cm_MergeStatus(cm_scache_t *dscp, */ 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; diff --git a/src/WINNT/afsd/cm_scache.h b/src/WINNT/afsd/cm_scache.h index 280ebba68..42cdcafdc 100644 --- a/src/WINNT/afsd/cm_scache.h +++ b/src/WINNT/afsd/cm_scache.h @@ -42,7 +42,7 @@ typedef struct cm_file_lock { 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] */ @@ -93,10 +93,10 @@ typedef struct cm_scache { 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. @@ -157,7 +157,7 @@ typedef struct cm_scache { 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 diff --git a/src/WINNT/afsd/cm_vnodeops.c b/src/WINNT/afsd/cm_vnodeops.c index cf3f9df31..a78559e07 100644 --- a/src/WINNT/afsd/cm_vnodeops.c +++ b/src/WINNT/afsd/cm_vnodeops.c @@ -262,7 +262,7 @@ long cm_CheckOpen(cm_scache_t *scp, int openMode, int trunc, cm_user_t *userp, 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 @@ -326,7 +326,7 @@ long cm_CheckOpen(cm_scache_t *scp, int openMode, int trunc, cm_user_t *userp, _done: - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); return code; } @@ -358,7 +358,7 @@ long cm_CheckNTOpen(cm_scache_t *scp, unsigned int desiredAccess, 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 @@ -440,7 +440,7 @@ long cm_CheckNTOpen(cm_scache_t *scp, unsigned int desiredAccess, 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; @@ -451,10 +451,10 @@ extern long cm_CheckNTOpenDone(cm_scache_t *scp, cm_user_t *userp, cm_req_t *req { 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; } @@ -483,13 +483,14 @@ long cm_CheckNTDelete(cm_scache_t *dscp, cm_scache_t *scp, cm_user_t *userp, 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; @@ -504,14 +505,15 @@ long cm_CheckNTDelete(cm_scache_t *dscp, cm_scache_t *scp, cm_user_t *userp, 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; @@ -519,14 +521,17 @@ long cm_CheckNTDelete(cm_scache_t *dscp, cm_scache_t *scp, cm_user_t *userp, /* 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). @@ -558,7 +563,8 @@ long cm_CheckNTDelete(cm_scache_t *dscp, cm_scache_t *scp, cm_user_t *userp, done: lock_ReleaseMutex(&bufferp->mx); buf_Release(bufferp); - lock_ReleaseMutex(&scp->mx); + if (releaseLock) + lock_ReleaseWrite(&scp->rw); return code; } @@ -591,10 +597,10 @@ long cm_ApplyDir(cm_scache_t *scp, cm_DirFuncp_t funcp, void *parmp, 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; @@ -745,7 +751,7 @@ long cm_ApplyDir(cm_scache_t *scp, cm_DirFuncp_t funcp, void *parmp, 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)) { @@ -754,7 +760,7 @@ long cm_ApplyDir(cm_scache_t *scp, cm_DirFuncp_t funcp, void *parmp, scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING; scp->bulkStatProgress = thyper; } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); #endif lock_ObtainMutex(&bufferp->mx); @@ -762,20 +768,20 @@ long cm_ApplyDir(cm_scache_t *scp, cm_DirFuncp_t funcp, void *parmp, /* 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; } @@ -783,7 +789,7 @@ long cm_ApplyDir(cm_scache_t *scp, cm_DirFuncp_t funcp, void *parmp, 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; @@ -961,7 +967,7 @@ long cm_LookupSearchProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *rockp, } /* 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) { @@ -974,12 +980,12 @@ 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; @@ -1033,7 +1039,7 @@ long cm_ReadMountPoint(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp) /* 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) @@ -1053,9 +1059,9 @@ long cm_FollowMountPoint(cm_scache_t *scp, cm_scache_t *dscp, cm_user_t *userp, 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; } @@ -1075,9 +1081,9 @@ long cm_FollowMountPoint(cm_scache_t *scp, cm_scache_t *dscp, cm_user_t *userp, 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 */ @@ -1109,7 +1115,7 @@ long cm_FollowMountPoint(cm_scache_t *scp, cm_scache_t *dscp, cm_user_t *userp, } /* 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); @@ -1117,7 +1123,7 @@ long cm_FollowMountPoint(cm_scache_t *scp, cm_scache_t *dscp, cm_user_t *userp, 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; @@ -1168,9 +1174,9 @@ long cm_FollowMountPoint(cm_scache_t *scp, cm_scache_t *dscp, cm_user_t *userp, 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: @@ -1341,11 +1347,11 @@ long cm_LookupInternal(cm_scache_t *dscp, char *namep, long flags, cm_user_t *us } /* 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; } @@ -1361,7 +1367,7 @@ long cm_LookupInternal(cm_scache_t *dscp, char *namep, long flags, cm_user_t *us 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; @@ -1369,7 +1375,7 @@ long cm_LookupInternal(cm_scache_t *dscp, char *namep, long flags, cm_user_t *us tscp = mountedScp; } else { - lock_ReleaseMutex(&tscp->mx); + lock_ReleaseWrite(&tscp->rw); } /* copy back pointer */ @@ -1378,10 +1384,10 @@ long cm_LookupInternal(cm_scache_t *dscp, char *namep, long flags, cm_user_t *us /* 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 */ @@ -1619,10 +1625,10 @@ long cm_Unlink(cm_scache_t *dscp, char *namep, cm_user_t *userp, cm_req_t *reqp) /* 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; @@ -1656,7 +1662,7 @@ long cm_Unlink(cm_scache_t *dscp, char *namep, cm_user_t *userp, cm_req_t *reqp) 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) { @@ -1668,7 +1674,7 @@ long cm_Unlink(cm_scache_t *dscp, char *namep, cm_user_t *userp, cm_req_t *reqp) */ dscp->cbServerp = NULL; } - lock_ReleaseMutex(&dscp->mx); + lock_ReleaseWrite(&dscp->rw); if (code == 0 && cm_CheckDirOpForSingleChange(&dirop)) { cm_DirDeleteEntry(&dirop, namep); @@ -1681,8 +1687,8 @@ long cm_Unlink(cm_scache_t *dscp, char *namep, cm_user_t *userp, cm_req_t *reqp) 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) { @@ -1691,13 +1697,13 @@ 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) { @@ -1761,7 +1767,7 @@ long cm_AssembleLink(cm_scache_t *linkScp, char *pathSuffixp, *newRootScpp = NULL; *newSpaceBufferp = NULL; - lock_ObtainMutex(&linkScp->mx); + lock_ObtainWrite(&linkScp->rw); code = cm_HandleLink(linkScp, userp, reqp); if (code) goto done; @@ -1841,7 +1847,7 @@ long cm_AssembleLink(cm_scache_t *linkScp, char *pathSuffixp, } done: - lock_ReleaseMutex(&linkScp->mx); + lock_ReleaseWrite(&linkScp->rw); return code; } #ifdef DEBUG_REFCOUNT @@ -2003,12 +2009,12 @@ long cm_NameI(cm_scache_t *rootSCachep, char *pathp, long flags, /* 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) { @@ -2021,7 +2027,7 @@ long cm_NameI(cm_scache_t *rootSCachep, char *pathp, long flags, 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; @@ -2100,7 +2106,7 @@ long cm_NameI(cm_scache_t *rootSCachep, char *pathp, long flags, } } else { /* not a symlink, we may be done */ - lock_ReleaseMutex(&tscp->mx); + lock_ReleaseWrite(&tscp->rw); if (tc == 0) { if (phase == 1) { phase = 2; @@ -2258,18 +2264,18 @@ long cm_TryBulkProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *rockp, 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 */ @@ -2295,7 +2301,7 @@ long cm_TryBulkProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *rockp, 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 @@ -2328,13 +2334,13 @@ cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp, 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; } @@ -2405,7 +2411,7 @@ cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp, /* 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 @@ -2426,7 +2432,7 @@ cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp, 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, @@ -2435,7 +2441,7 @@ cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp, 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) { @@ -2502,7 +2508,7 @@ long cm_SetLength(cm_scache_t *scp, osi_hyper_t *sizep, cm_user_t *userp, 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) @@ -2520,9 +2526,9 @@ long cm_SetLength(cm_scache_t *scp, osi_hyper_t *sizep, cm_user_t *userp, 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. */ @@ -2530,7 +2536,7 @@ long cm_SetLength(cm_scache_t *scp, osi_hyper_t *sizep, cm_user_t *userp, 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. @@ -2581,7 +2587,7 @@ long cm_SetLength(cm_scache_t *scp, osi_hyper_t *sizep, cm_user_t *userp, | CM_SCACHESYNC_SETSTATUS | CM_SCACHESYNC_SETSIZE); done: - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); lock_ReleaseWrite(&scp->bufCreateLock); return code; @@ -2603,13 +2609,14 @@ long cm_SetAttr(cm_scache_t *scp, cm_attr_t *attrp, cm_user_t *userp, 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); @@ -2617,7 +2624,7 @@ long cm_SetAttr(cm_scache_t *scp, cm_attr_t *attrp, cm_user_t *userp, 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); @@ -2640,7 +2647,7 @@ long cm_SetAttr(cm_scache_t *scp, cm_attr_t *attrp, cm_user_t *userp, 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, @@ -2651,7 +2658,7 @@ long cm_SetAttr(cm_scache_t *scp, cm_attr_t *attrp, cm_user_t *userp, */ if (afsInStatus.Mask & AFS_SETMODE) cm_FreeAllACLEnts(scp); - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); return code; } @@ -2696,9 +2703,9 @@ long cm_Create(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp, * 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 { @@ -2742,12 +2749,12 @@ long cm_Create(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp, 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 @@ -2758,7 +2765,7 @@ long cm_Create(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp, 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, @@ -2767,7 +2774,7 @@ long cm_Create(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp, &newFileCallback, 0); didEnd = 1; } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); *scpp = scp; } } @@ -2793,7 +2800,7 @@ long cm_FSync(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp) 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 @@ -2805,7 +2812,7 @@ long cm_FSync(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp) scp->flags &= ~(CM_SCACHEFLAG_OVERQUOTA | CM_SCACHEFLAG_OUTOFSPACE); } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); } return code; } @@ -2851,9 +2858,9 @@ long cm_MakeDir(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp, * 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 { @@ -2897,12 +2904,12 @@ long cm_MakeDir(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp, 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 @@ -2913,7 +2920,7 @@ long cm_MakeDir(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp, 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); @@ -2921,7 +2928,7 @@ long cm_MakeDir(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp, &newDirCallback, 0); didEnd = 1; } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); cm_ReleaseSCache(scp); } } @@ -2961,9 +2968,9 @@ long cm_Link(cm_scache_t *dscp, char *namep, cm_scache_t *sscp, long flags, } 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); @@ -3004,12 +3011,12 @@ long cm_Link(cm_scache_t *dscp, char *namep, cm_scache_t *sscp, long flags, 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)) { @@ -3045,9 +3052,9 @@ long cm_SymLink(cm_scache_t *dscp, char *namep, char *contentsp, long flags, * 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) { @@ -3086,12 +3093,12 @@ long cm_SymLink(cm_scache_t *dscp, char *namep, char *contentsp, long flags, 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)) { @@ -3114,12 +3121,12 @@ long cm_SymLink(cm_scache_t *dscp, char *namep, char *contentsp, long flags, 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); } } @@ -3145,9 +3152,9 @@ long cm_RemoveDir(cm_scache_t *dscp, char *namep, cm_user_t *userp, * 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; @@ -3183,13 +3190,13 @@ long cm_RemoveDir(cm_scache_t *dscp, char *namep, cm_user_t *userp, 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)) { @@ -3208,7 +3215,7 @@ long cm_RemoveDir(cm_scache_t *dscp, char *namep, cm_user_t *userp, 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 */ @@ -3217,7 +3224,7 @@ long cm_Open(cm_scache_t *scp, int type, cm_user_t *userp) scp->prefetch.end.HighPart = 0; /* release mutex on contents */ - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); /* we're done */ return 0; @@ -3253,12 +3260,12 @@ long cm_Rename(cm_scache_t *oldDscp, char *oldNamep, cm_scache_t *newDscp, 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); } @@ -3279,28 +3286,28 @@ long cm_Rename(cm_scache_t *oldDscp, char *oldNamep, cm_scache_t *newDscp, 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); } } @@ -3308,28 +3315,28 @@ long cm_Rename(cm_scache_t *oldDscp, char *oldNamep, cm_scache_t *newDscp, 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); } } @@ -3377,13 +3384,13 @@ long cm_Rename(cm_scache_t *oldDscp, char *oldNamep, cm_scache_t *newDscp, 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)) { @@ -3421,12 +3428,12 @@ long cm_Rename(cm_scache_t *oldDscp, char *oldNamep, cm_scache_t *newDscp, 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 @@ -3776,7 +3783,7 @@ static void cm_LockRangeSubtract(cm_range_t * pos, const cm_range_t * neg) } } -/* 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, @@ -3860,7 +3867,7 @@ 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, @@ -3955,7 +3962,7 @@ static void cm_PutFileLock(cm_file_lock_t *l) { 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) { @@ -3975,7 +3982,7 @@ long cm_IntSetLock(cm_scache_t * scp, cm_user_t * userp, int lockType, 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); @@ -3997,12 +4004,12 @@ long cm_IntSetLock(cm_scache_t * scp, cm_user_t * userp, int lockType, 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; @@ -4017,7 +4024,7 @@ long cm_IntReleaseLock(cm_scache_t * scp, cm_user_t * userp, 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); @@ -4040,12 +4047,12 @@ long cm_IntReleaseLock(cm_scache_t * scp, cm_user_t * userp, 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: @@ -4131,7 +4138,7 @@ long cm_LockCheckPerms(cm_scache_t * scp, 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, @@ -4498,7 +4505,7 @@ long cm_Lock(cm_scache_t *scp, unsigned char sLockType, 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, @@ -4877,7 +4884,7 @@ long cm_Unlock(cm_scache_t *scp, return code; } -/* called with scp->mx held */ +/* called with scp->rw held */ void cm_LockMarkSCacheLost(cm_scache_t * scp) { cm_file_lock_t *fileLock; @@ -4980,7 +4987,7 @@ void cm_CheckLocks() 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)) @@ -4997,7 +5004,7 @@ void cm_CheckLocks() 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; @@ -5017,7 +5024,7 @@ void cm_CheckLocks() scp, (int) scp->serverLock); - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); do { code = cm_ConnFromFID(&cfid, userp, @@ -5038,7 +5045,7 @@ void cm_CheckLocks() 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); @@ -5098,7 +5105,7 @@ void cm_CheckLocks() cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_LOCK); post_syncopdone: - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); lock_ObtainWrite(&cm_scacheLock); @@ -5125,7 +5132,7 @@ void cm_CheckLocks() 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; @@ -5178,7 +5185,7 @@ long cm_RetryLock(cm_file_lock_t *oldFileLock, int client_is_dead) 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, @@ -5190,7 +5197,7 @@ long cm_RetryLock(cm_file_lock_t *oldFileLock, int client_is_dead) } code = 0; } else if (code) { - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); return code; } @@ -5213,7 +5220,7 @@ long cm_RetryLock(cm_file_lock_t *oldFileLock, int client_is_dead) } lock_ReleaseWrite(&cm_scacheLock); - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); return 0; } @@ -5257,7 +5264,7 @@ long cm_RetryLock(cm_file_lock_t *oldFileLock, int client_is_dead) if (code != 0) { lock_ReleaseWrite(&cm_scacheLock); - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); goto handleCode; } @@ -5306,7 +5313,7 @@ long cm_RetryLock(cm_file_lock_t *oldFileLock, int client_is_dead) } lock_ReleaseWrite(&cm_scacheLock); - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); return 0; @@ -5409,7 +5416,7 @@ long cm_RetryLock(cm_file_lock_t *oldFileLock, int client_is_dead) 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); @@ -5465,11 +5472,11 @@ void cm_ReleaseAllLocks(void) { 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)); @@ -5481,7 +5488,7 @@ void cm_ReleaseAllLocks(void) cm_UnlockByKey(scp, key, 0, userp, &req); cm_ReleaseSCache(scp); cm_ReleaseUser(userp); - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); } } } diff --git a/src/WINNT/afsd/cm_volstat.c b/src/WINNT/afsd/cm_volstat.c index 328ca3c72..23e1c9463 100644 --- a/src/WINNT/afsd/cm_volstat.c +++ b/src/WINNT/afsd/cm_volstat.c @@ -311,11 +311,11 @@ cm_VolStatus_Path_To_ID(const char * share, const char * path, afs_uint32 * cell 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; } @@ -326,7 +326,7 @@ cm_VolStatus_Path_To_ID(const char * share, const char * path, afs_uint32 * cell *volID = scp->fid.volume; *pstatus = cm_GetVolumeStatus(scp->volp, scp->fid.volume); - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); cm_ReleaseSCache(scp); done: @@ -355,11 +355,11 @@ cm_VolStatus_Path_To_DFSlink(const char * share, const char * path, afs_uint32 * 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; } @@ -382,7 +382,7 @@ cm_VolStatus_Path_To_DFSlink(const char * share, const char * path, afs_uint32 * goto done; } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); cm_ReleaseSCache(scp); done: diff --git a/src/WINNT/afsd/cm_volume.c b/src/WINNT/afsd/cm_volume.c index 1c0a9e27b..3d87d94da 100644 --- a/src/WINNT/afsd/cm_volume.c +++ b/src/WINNT/afsd/cm_volume.c @@ -983,9 +983,9 @@ void cm_RefreshVolumes(void) && !(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); } } @@ -1577,9 +1577,9 @@ cm_VolumeRenewROCallbacks(void) 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); diff --git a/src/WINNT/afsd/rawops.c b/src/WINNT/afsd/rawops.c index 48ff81dc5..69f2cbf04 100644 --- a/src/WINNT/afsd/rawops.c +++ b/src/WINNT/afsd/rawops.c @@ -33,7 +33,7 @@ long ReadData(cm_scache_t *scp, osi_hyper_t offset, long count, char *op, 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, @@ -82,11 +82,11 @@ long ReadData(cm_scache_t *scp, osi_hyper_t offset, long count, char *op, 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; @@ -134,7 +134,7 @@ long ReadData(cm_scache_t *scp, osi_hyper_t offset, long count, char *op, } /* while 1 */ done: - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); //lock_ReleaseMutex(&fidp->mx); if (bufferp) buf_Release(bufferp); @@ -169,7 +169,7 @@ long WriteData(cm_scache_t *scp, osi_hyper_t offset, long count, char *op, 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, @@ -243,12 +243,12 @@ long WriteData(cm_scache_t *scp, osi_hyper_t offset, long count, char *op, 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; @@ -298,9 +298,9 @@ long WriteData(cm_scache_t *scp, osi_hyper_t offset, long count, char *op, 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; } @@ -349,16 +349,16 @@ long WriteData(cm_scache_t *scp, osi_hyper_t offset, long count, char *op, } /* 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); } diff --git a/src/WINNT/afsd/smb.c b/src/WINNT/afsd/smb.c index 4c0c0cd05..8cff243c9 100644 --- a/src/WINNT/afsd/smb.c +++ b/src/WINNT/afsd/smb.c @@ -1582,9 +1582,9 @@ void smb_ReleaseFID(smb_fid_t *fidp) 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; } @@ -2057,13 +2057,13 @@ void smb_DeleteDirSearch(smb_dirSearch_t *dsp) 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); @@ -3171,9 +3171,9 @@ long smb_ReceiveCoreReadRaw(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp 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; @@ -3725,7 +3725,7 @@ void smb_WaitingLocksDaemon() 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); @@ -3739,7 +3739,7 @@ void smb_WaitingLocksDaemon() free(wl); } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); } else { @@ -4090,11 +4090,11 @@ smb_ApplyDirListPatches(smb_dirListPatch_t **dirPatchespp, *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; @@ -4103,6 +4103,7 @@ smb_ApplyDirListPatches(smb_dirListPatch_t **dirPatchespp, 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) @@ -4125,7 +4126,7 @@ smb_ApplyDirListPatches(smb_dirListPatch_t **dirPatchespp, /* copy out file length */ *((u_long *)dptr) = scp->length.LowPart; dptr += 4; - lock_ReleaseMutex(&scp->mx); + lock_ReleaseRead(&scp->rw); cm_ReleaseSCache(scp); } @@ -4320,14 +4321,14 @@ long smb_ReceiveCoreSearchDir(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *ou * 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); @@ -4345,11 +4346,11 @@ long smb_ReceiveCoreSearchDir(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *ou 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); @@ -4418,7 +4419,7 @@ long smb_ReceiveCoreSearchDir(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *ou buf_Release(bufferp); bufferp = NULL; } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); code = buf_Get(scp, &thyper, &bufferp); lock_ObtainMutex(&dsp->mx); @@ -4427,7 +4428,7 @@ long smb_ReceiveCoreSearchDir(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *ou */ 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)) { @@ -4442,7 +4443,7 @@ long smb_ReceiveCoreSearchDir(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *ou code = cm_TryBulkStat(scp, &thyper, userp, &req); } } else { - lock_ObtainMutex(&scp->mx); + lock_ObtainWrite(&scp->rw); } lock_ReleaseMutex(&dsp->mx); if (code) { @@ -4634,7 +4635,7 @@ long smb_ReceiveCoreSearchDir(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *ou } /* while copying data for dir listing */ /* release the mutex */ - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); if (bufferp) { buf_Release(bufferp); bufferp = NULL; @@ -4741,12 +4742,12 @@ long smb_ReceiveCoreCheckPath(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *ou #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; @@ -4760,7 +4761,7 @@ long smb_ReceiveCoreCheckPath(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *ou if (!(attrs & SMB_ATTR_DIRECTORY)) code = CM_ERROR_NOTDIR; - lock_ReleaseMutex(&newScp->mx); + lock_ReleaseWrite(&newScp->rw); cm_ReleaseSCache(newScp); cm_ReleaseUser(userp); @@ -4832,11 +4833,11 @@ long smb_ReceiveCoreSetFileAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_pack * 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; @@ -4846,7 +4847,7 @@ long smb_ReceiveCoreSetFileAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_pack /* 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; @@ -4868,7 +4869,7 @@ long smb_ReceiveCoreSetFileAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_pack attr.unixModeBits = newScp->unixModeBits | 0222; attr.mask |= CM_ATTRMASK_UNIXMODEBITS; } - lock_ReleaseMutex(&newScp->mx); + lock_ReleaseWrite(&newScp->rw); /* now call setattr */ if (attr.mask) @@ -4999,11 +5000,11 @@ long smb_ReceiveCoreGetFileAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_pack #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; @@ -5040,7 +5041,7 @@ long smb_ReceiveCoreGetFileAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_pack 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); @@ -5177,9 +5178,9 @@ long smb_ReceiveCoreOpen(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) /* 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); @@ -5194,7 +5195,7 @@ long smb_ReceiveCoreOpen(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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); @@ -5205,7 +5206,7 @@ long smb_ReceiveCoreOpen(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) /* 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); @@ -6166,7 +6167,7 @@ long smb_CloseFID(smb_vc_t *vcp, smb_fid_t *fidp, cm_user_t *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 @@ -6185,7 +6186,7 @@ long smb_CloseFID(smb_vc_t *vcp, smb_fid_t *fidp, cm_user_t *userp, post_syncopdone: - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); lock_ObtainMutex(&fidp->mx); } @@ -6258,20 +6259,20 @@ long smb_CloseFID(smb_vc_t *vcp, smb_fid_t *fidp, cm_user_t *userp, 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); } @@ -6342,7 +6343,7 @@ long smb_ReadData(smb_fid_t *fidp, osi_hyper_t *offsetp, afs_uint32 count, char 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; @@ -6402,11 +6403,11 @@ long smb_ReadData(smb_fid_t *fidp, osi_hyper_t *offsetp, afs_uint32 count, char 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; @@ -6459,7 +6460,7 @@ long smb_ReadData(smb_fid_t *fidp, osi_hyper_t *offsetp, afs_uint32 count, char } /* while 1 */ done: - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); if (bufferp) buf_Release(bufferp); @@ -6519,7 +6520,7 @@ long smb_WriteData(smb_fid_t *fidp, osi_hyper_t *offsetp, afs_uint32 count, char 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 @@ -6594,12 +6595,12 @@ long smb_WriteData(smb_fid_t *fidp, osi_hyper_t *offsetp, afs_uint32 count, char 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; @@ -6650,9 +6651,9 @@ long smb_WriteData(smb_fid_t *fidp, osi_hyper_t *offsetp, afs_uint32 count, char 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) { @@ -6700,7 +6701,7 @@ long smb_WriteData(smb_fid_t *fidp, osi_hyper_t *offsetp, afs_uint32 count, char } /* while 1 */ done: - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); if (bufferp) { lock_ReleaseMutex(&bufferp->mx); @@ -6721,13 +6722,13 @@ long smb_WriteData(smb_fid_t *fidp, osi_hyper_t *offsetp, afs_uint32 count, char 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); @@ -6809,9 +6810,9 @@ long smb_ReceiveCoreWrite(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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); @@ -7053,9 +7054,9 @@ long smb_ReceiveCoreWriteRaw(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *out 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); @@ -7209,9 +7210,9 @@ long smb_ReceiveCoreRead(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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); @@ -7557,9 +7558,9 @@ long smb_ReceiveCoreCreate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) /* 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; @@ -7620,7 +7621,7 @@ long smb_ReceiveCoreSeek(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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) { @@ -7643,7 +7644,7 @@ long smb_ReceiveCoreSeek(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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); @@ -9743,9 +9744,9 @@ void smb_Shutdown(void) 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); } diff --git a/src/WINNT/afsd/smb3.c b/src/WINNT/afsd/smb3.c index b24dec783..a38f38c4e 100644 --- a/src/WINNT/afsd/smb3.c +++ b/src/WINNT/afsd/smb3.c @@ -2421,9 +2421,9 @@ long smb_ReceiveTran2Open(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *op) /* 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; @@ -2447,7 +2447,7 @@ long smb_ReceiveTran2Open(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *op) /* 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); @@ -2469,7 +2469,7 @@ long smb_ReceiveTran2Open(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *op) 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 */ @@ -2863,7 +2863,7 @@ long smb_ReceiveTran2QPathInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t } #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); @@ -2871,6 +2871,8 @@ long smb_ReceiveTran2QPathInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t 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. */ @@ -2929,7 +2931,7 @@ long smb_ReceiveTran2QPathInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t 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; @@ -2975,7 +2977,7 @@ long smb_ReceiveTran2QPathInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t /* 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) { @@ -3149,19 +3151,19 @@ long smb_ReceiveTran2SetPathInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet /* 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; @@ -3188,7 +3190,7 @@ long smb_ReceiveTran2SetPathInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet attr.unixModeBits = scp->unixModeBits | 0222; } } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseRead(&scp->rw); lock_ReleaseMutex(&fidp->mx); /* call setattr */ @@ -3230,6 +3232,7 @@ long smb_ReceiveTran2QFileInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t cm_scache_t *scp; smb_tran2QFileInfo_t qfi; long code = 0; + int readlock = 0; cm_req_t req; cm_InitReq(&req); @@ -3288,7 +3291,7 @@ long smb_ReceiveTran2QFileInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t 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) @@ -3296,6 +3299,9 @@ long smb_ReceiveTran2QFileInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t 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. */ @@ -3325,9 +3331,9 @@ long smb_ReceiveTran2QFileInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t 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 @@ -3341,7 +3347,10 @@ long smb_ReceiveTran2QFileInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t /* 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); @@ -3443,20 +3452,20 @@ long smb_ReceiveTran2SetFileInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet /* 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; @@ -3488,7 +3497,7 @@ long smb_ReceiveTran2SetFileInfo(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet attr.unixModeBits = scp->unixModeBits | 0222; } } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseRead(&scp->rw); lock_ReleaseMutex(&fidp->mx); /* call setattr */ @@ -3843,10 +3852,10 @@ smb_ApplyV3DirListPatches(cm_scache_t *dscp,smb_dirListPatch_t **dirPatchespp, 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; @@ -3866,12 +3875,12 @@ smb_ApplyV3DirListPatches(cm_scache_t *dscp,smb_dirListPatch_t **dirPatchespp, 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; @@ -3985,7 +3994,7 @@ smb_ApplyV3DirListPatches(cm_scache_t *dscp,smb_dirListPatch_t **dirPatchespp, /* 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; @@ -4001,9 +4010,11 @@ smb_ApplyV3DirListPatches(cm_scache_t *dscp,smb_dirListPatch_t **dirPatchespp, 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) { @@ -4105,7 +4116,7 @@ smb_ApplyV3DirListPatches(cm_scache_t *dscp,smb_dirListPatch_t **dirPatchespp, *dptr++ = (attr >> 8) & 0xff; } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseRead(&scp->rw); cm_ReleaseSCache(scp); } @@ -4924,13 +4935,13 @@ long smb_ReceiveTran2SearchDir(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t * 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); @@ -4943,11 +4954,11 @@ long smb_ReceiveTran2SearchDir(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t } /* 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); @@ -5029,7 +5040,7 @@ long smb_ReceiveTran2SearchDir(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t buf_Release(bufferp); bufferp = NULL; } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); code = buf_Get(scp, &thyper, &bufferp); lock_ObtainMutex(&dsp->mx); @@ -5039,7 +5050,7 @@ long smb_ReceiveTran2SearchDir(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t 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 */ @@ -5052,7 +5063,7 @@ long smb_ReceiveTran2SearchDir(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t code = cm_TryBulkStat(scp, &thyper, userp, &req); } } else { - lock_ObtainMutex(&scp->mx); + lock_ObtainWrite(&scp->rw); } lock_ReleaseMutex(&dsp->mx); if (code) { @@ -5333,7 +5344,7 @@ long smb_ReceiveTran2SearchDir(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t } /* release the mutex */ - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); if (bufferp) { buf_Release(bufferp); bufferp = NULL; @@ -5698,9 +5709,9 @@ long smb_ReceiveV3OpenX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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; @@ -5726,7 +5737,7 @@ long smb_ReceiveV3OpenX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) /* 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); @@ -5744,7 +5755,7 @@ long smb_ReceiveV3OpenX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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); @@ -5833,7 +5844,7 @@ long smb_ReceiveV3LockingX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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 @@ -6066,7 +6077,7 @@ long smb_ReceiveV3LockingX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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); @@ -6083,6 +6094,7 @@ long smb_ReceiveV3GetAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t * afs_uint32 searchTime; cm_user_t *userp; cm_req_t req; + int readlock = 0; cm_InitReq(&req); @@ -6114,7 +6126,7 @@ long smb_ReceiveV3GetAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t * /* 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) @@ -6122,6 +6134,8 @@ long smb_ReceiveV3GetAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t * 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. @@ -6148,7 +6162,10 @@ long smb_ReceiveV3GetAttributes(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t * 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); @@ -6304,9 +6321,9 @@ long smb_ReceiveV3WriteX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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; @@ -6427,9 +6444,9 @@ long smb_ReceiveV3ReadX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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) { @@ -7244,9 +7261,9 @@ long smb_ReceiveNTCreateX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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) @@ -7270,9 +7287,9 @@ long smb_ReceiveNTCreateX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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; @@ -7305,7 +7322,7 @@ long smb_ReceiveNTCreateX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) /* 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; @@ -7333,7 +7350,7 @@ long smb_ReceiveNTCreateX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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)); @@ -7912,9 +7929,9 @@ long smb_ReceiveNTTranCreate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *out 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) @@ -7936,9 +7953,9 @@ long smb_ReceiveNTTranCreate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *out 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; @@ -7995,7 +8012,7 @@ long smb_ReceiveNTTranCreate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *out 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 */ @@ -8017,7 +8034,6 @@ long smb_ReceiveNTTranCreate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *out 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; @@ -8045,7 +8061,7 @@ long smb_ReceiveNTTranCreate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *out 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 */ @@ -8070,10 +8086,8 @@ long smb_ReceiveNTTranCreate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *out 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)) { @@ -8081,7 +8095,7 @@ long smb_ReceiveNTTranCreate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *out 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); @@ -8164,12 +8178,12 @@ long smb_ReceiveNTTranNotifyChange(smb_vc_t *vcp, smb_packet_t *inp, 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; @@ -8417,12 +8431,12 @@ void smb_NotifyChange(DWORD action, DWORD notifyFilter, 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; @@ -8567,12 +8581,12 @@ long smb_ReceiveNTCancel(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp) 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);