From: Jeffrey Altman Date: Mon, 3 Mar 2008 04:24:17 +0000 (+0000) Subject: windows-scache-mx-to-rw-20080302 X-Git-Tag: BP-openafs-windows-kdfs-ifs~53 X-Git-Url: https://git.michaelhowe.org/gitweb/?a=commitdiff_plain;h=69f9b46e69bb7c8c9356b062a8f4908fe38ad14b;p=packages%2Fo%2Fopenafs.git 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. --- 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 91e5de4f9..85ba6c8a9 100644 --- a/src/WINNT/afsd/cm_access.c +++ b/src/WINNT/afsd/cm_access.c @@ -55,7 +55,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); @@ -65,7 +65,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; } @@ -74,7 +74,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, @@ -135,7 +135,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; @@ -171,23 +171,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 f3b25849e..c010982f0 100644 --- a/src/WINNT/afsd/cm_aclent.c +++ b/src/WINNT/afsd/cm_aclent.c @@ -39,7 +39,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) @@ -127,13 +127,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 a56e55a60..4df488420 100644 --- a/src/WINNT/afsd/cm_buf.c +++ b/src/WINNT/afsd/cm_buf.c @@ -514,12 +514,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); } } @@ -1386,7 +1386,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. @@ -1439,7 +1439,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) { @@ -1551,14 +1551,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 4a076a39d..65eac2921 100644 --- a/src/WINNT/afsd/cm_callback.c +++ b/src/WINNT/afsd/cm_callback.c @@ -205,9 +205,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); @@ -253,11 +253,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); @@ -480,7 +480,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 */ @@ -491,7 +491,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); @@ -757,9 +757,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; @@ -869,9 +869,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; @@ -1555,9 +1555,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 @@ -1614,7 +1614,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, @@ -1709,9 +1709,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 ) { @@ -1800,7 +1800,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", @@ -1825,7 +1825,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); @@ -1920,9 +1920,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 585c05240..9d8df76d4 100644 --- a/src/WINNT/afsd/cm_conn.c +++ b/src/WINNT/afsd/cm_conn.c @@ -514,20 +514,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 857872e7e..5b9c65ff6 100644 --- a/src/WINNT/afsd/cm_dcache.c +++ b/src/WINNT/afsd/cm_dcache.c @@ -81,9 +81,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; } @@ -92,13 +92,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; } @@ -143,7 +143,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 { @@ -260,7 +260,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); @@ -302,7 +302,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; @@ -348,7 +348,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); @@ -399,7 +399,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); @@ -440,11 +440,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; } @@ -458,7 +458,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; @@ -547,14 +547,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; } @@ -598,7 +598,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; } @@ -630,9 +630,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; } @@ -691,7 +691,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; } @@ -707,7 +707,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; } @@ -718,12 +718,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); @@ -748,10 +748,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; @@ -762,7 +762,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); @@ -812,9 +812,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) { @@ -824,9 +824,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); @@ -900,9 +900,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; @@ -960,9 +960,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; @@ -1051,7 +1051,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); @@ -1091,7 +1091,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; } @@ -1156,12 +1156,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; } @@ -1175,7 +1175,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; } @@ -1183,13 +1183,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 */ @@ -1223,7 +1223,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 @@ -1277,7 +1277,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 */ @@ -1294,15 +1294,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 */ @@ -1385,22 +1385,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)), @@ -1599,7 +1599,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); @@ -1609,7 +1609,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; @@ -1677,7 +1677,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); @@ -1704,9 +1704,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 75d13b28c..463d2fbf4 100644 --- a/src/WINNT/afsd/cm_dir.c +++ b/src/WINNT/afsd/cm_dir.c @@ -134,10 +134,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. @@ -232,10 +232,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. @@ -269,10 +269,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. @@ -338,7 +338,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) { @@ -442,7 +442,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) @@ -475,7 +475,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) @@ -526,7 +526,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) @@ -575,10 +575,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. @@ -634,10 +634,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. @@ -692,10 +692,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. @@ -747,10 +747,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. @@ -800,15 +800,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 @@ -861,10 +861,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, @@ -957,7 +957,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, @@ -991,7 +991,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) { @@ -1027,14 +1027,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 && @@ -1049,12 +1049,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) { @@ -1105,14 +1105,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); } @@ -1120,7 +1120,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) { @@ -1130,7 +1130,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 && @@ -1143,7 +1143,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"); @@ -1155,7 +1155,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) { @@ -1191,9 +1191,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) { @@ -1220,7 +1220,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) { @@ -1259,7 +1259,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); @@ -1281,7 +1281,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) { @@ -1303,7 +1303,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) { @@ -1332,7 +1332,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) { @@ -1364,7 +1364,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 @@ -1381,12 +1381,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) { @@ -1431,13 +1431,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) @@ -1445,11 +1445,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); @@ -1461,7 +1461,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) @@ -1501,15 +1501,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 @@ -1583,14 +1583,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; } @@ -1600,13 +1600,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 486b6bce8..8dca8afd0 100644 --- a/src/WINNT/afsd/cm_freelance.c +++ b/src/WINNT/afsd/cm_freelance.c @@ -401,9 +401,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); @@ -414,9 +414,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 13e49fb39..57be51997 100644 --- a/src/WINNT/afsd/cm_ioctl.c +++ b/src/WINNT/afsd/cm_ioctl.c @@ -64,9 +64,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; @@ -85,10 +85,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; @@ -155,9 +155,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); } @@ -736,9 +736,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); @@ -1260,11 +1260,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; } @@ -1276,7 +1276,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; @@ -1304,25 +1304,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 */ @@ -1333,9 +1333,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); @@ -2169,7 +2169,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) @@ -2184,7 +2184,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); @@ -2194,12 +2194,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 43a4401fb..34be33f8f 100644 --- a/src/WINNT/afsd/cm_scache.c +++ b/src/WINNT/afsd/cm_scache.c @@ -318,7 +318,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"); @@ -374,7 +374,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 @@ -531,9 +531,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) { @@ -550,7 +550,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); @@ -577,7 +577,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"); @@ -739,7 +739,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; @@ -770,7 +770,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); @@ -836,7 +836,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; @@ -862,7 +862,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 @@ -1231,9 +1231,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; @@ -1258,9 +1258,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; @@ -1301,10 +1301,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(); @@ -1392,7 +1392,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) @@ -1737,7 +1737,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 b00220a58..ce3078efb 100644 --- a/src/WINNT/afsd/cm_scache.h +++ b/src/WINNT/afsd/cm_scache.h @@ -38,7 +38,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] */ @@ -89,10 +89,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. @@ -153,7 +153,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 6d77ede7d..9b9f6ddd1 100644 --- a/src/WINNT/afsd/cm_vnodeops.c +++ b/src/WINNT/afsd/cm_vnodeops.c @@ -260,7 +260,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 @@ -324,7 +324,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; } @@ -356,7 +356,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 @@ -438,7 +438,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; @@ -449,10 +449,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; } @@ -481,13 +481,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; @@ -502,14 +503,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; @@ -517,14 +519,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). @@ -556,7 +561,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; } @@ -589,10 +595,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; @@ -743,7 +749,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)) { @@ -752,7 +758,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); @@ -760,20 +766,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; } @@ -781,7 +787,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; @@ -959,7 +965,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) { @@ -972,12 +978,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; @@ -1031,7 +1037,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) @@ -1051,9 +1057,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; } @@ -1073,9 +1079,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 */ @@ -1107,7 +1113,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); @@ -1115,7 +1121,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; @@ -1166,9 +1172,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: @@ -1339,11 +1345,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; } @@ -1359,7 +1365,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; @@ -1367,7 +1373,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 */ @@ -1376,10 +1382,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 */ @@ -1617,10 +1623,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; @@ -1654,7 +1660,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) { @@ -1666,7 +1672,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); @@ -1679,8 +1685,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) { @@ -1689,13 +1695,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) { @@ -1759,7 +1765,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; @@ -1839,7 +1845,7 @@ long cm_AssembleLink(cm_scache_t *linkScp, char *pathSuffixp, } done: - lock_ReleaseMutex(&linkScp->mx); + lock_ReleaseWrite(&linkScp->rw); return code; } #ifdef DEBUG_REFCOUNT @@ -2001,12 +2007,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) { @@ -2019,7 +2025,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; @@ -2098,7 +2104,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; @@ -2256,18 +2262,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 */ @@ -2293,7 +2299,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 @@ -2326,13 +2332,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; } @@ -2403,7 +2409,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 @@ -2424,7 +2430,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, @@ -2433,7 +2439,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) { @@ -2500,7 +2506,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) @@ -2518,9 +2524,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. */ @@ -2528,7 +2534,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. @@ -2579,7 +2585,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; @@ -2601,13 +2607,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); @@ -2615,7 +2622,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); @@ -2638,7 +2645,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, @@ -2649,7 +2656,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; } @@ -2694,9 +2701,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 { @@ -2740,12 +2747,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 @@ -2756,7 +2763,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, @@ -2765,7 +2772,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; } } @@ -2791,7 +2798,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 @@ -2803,7 +2810,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; } @@ -2849,9 +2856,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 { @@ -2895,12 +2902,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 @@ -2911,7 +2918,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); @@ -2919,7 +2926,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); } } @@ -2959,9 +2966,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); @@ -3002,12 +3009,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)) { @@ -3043,9 +3050,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) { @@ -3084,12 +3091,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)) { @@ -3112,12 +3119,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); } } @@ -3143,9 +3150,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; @@ -3181,13 +3188,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)) { @@ -3206,7 +3213,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 */ @@ -3215,7 +3222,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; @@ -3251,12 +3258,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); } @@ -3277,28 +3284,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); } } @@ -3306,28 +3313,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); } } @@ -3375,13 +3382,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)) { @@ -3419,12 +3426,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 @@ -3774,7 +3781,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, @@ -3858,7 +3865,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, @@ -3953,7 +3960,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) { @@ -3973,7 +3980,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); @@ -3995,12 +4002,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; @@ -4015,7 +4022,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); @@ -4038,12 +4045,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: @@ -4129,7 +4136,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, @@ -4496,7 +4503,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, @@ -4875,7 +4882,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; @@ -4978,7 +4985,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)) @@ -4995,7 +5002,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; @@ -5015,7 +5022,7 @@ void cm_CheckLocks() scp, (int) scp->serverLock); - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); do { code = cm_ConnFromFID(&cfid, userp, @@ -5036,7 +5043,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); @@ -5096,7 +5103,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); @@ -5123,7 +5130,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; @@ -5176,7 +5183,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, @@ -5188,7 +5195,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; } @@ -5211,7 +5218,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; } @@ -5255,7 +5262,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; } @@ -5304,7 +5311,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; @@ -5407,7 +5414,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); @@ -5463,11 +5470,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)); @@ -5479,7 +5486,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 420f275d2..b24b89474 100644 --- a/src/WINNT/afsd/cm_volume.c +++ b/src/WINNT/afsd/cm_volume.c @@ -979,9 +979,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); } } @@ -1573,9 +1573,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 ac342a462..03a48e3d1 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; } @@ -344,16 +344,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 6cb1fa59b..a21bd29cb 100644 --- a/src/WINNT/afsd/smb.c +++ b/src/WINNT/afsd/smb.c @@ -1486,9 +1486,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; } @@ -1886,13 +1886,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); @@ -2920,9 +2920,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; @@ -3445,7 +3445,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); @@ -3459,7 +3459,7 @@ void smb_WaitingLocksDaemon() free(wl); } - lock_ReleaseMutex(&scp->mx); + lock_ReleaseWrite(&scp->rw); } else { @@ -3810,11 +3810,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; @@ -3823,6 +3823,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) @@ -3845,7 +3846,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); } @@ -4040,14 +4041,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); @@ -4065,11 +4066,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); @@ -4138,7 +4139,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); @@ -4147,7 +4148,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)) { @@ -4162,7 +4163,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) { @@ -4354,7 +4355,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; @@ -4461,12 +4462,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; @@ -4480,7 +4481,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); @@ -4552,11 +4553,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; @@ -4566,7 +4567,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; @@ -4588,7 +4589,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) @@ -4719,11 +4720,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; @@ -4760,7 +4761,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); @@ -4897,9 +4898,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); @@ -4914,7 +4915,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); @@ -4925,7 +4926,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); @@ -5886,7 +5887,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 @@ -5905,7 +5906,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); } @@ -5978,20 +5979,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); } @@ -6057,7 +6058,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; @@ -6117,11 +6118,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; @@ -6169,7 +6170,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); @@ -6224,7 +6225,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 @@ -6299,12 +6300,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; @@ -6355,9 +6356,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) { @@ -6400,7 +6401,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); @@ -6421,13 +6422,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); @@ -6509,9 +6510,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); @@ -6728,9 +6729,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); @@ -6876,9 +6877,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); @@ -7220,9 +7221,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; @@ -7283,7 +7284,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) { @@ -7306,7 +7307,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); @@ -9220,9 +9221,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 6aa394be9..75acd795c 100644 --- a/src/WINNT/afsd/smb3.c +++ b/src/WINNT/afsd/smb3.c @@ -2415,9 +2415,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; @@ -2441,7 +2441,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); @@ -2463,7 +2463,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 */ @@ -2857,7 +2857,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); @@ -2865,6 +2865,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. */ @@ -2923,7 +2925,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; @@ -2969,7 +2971,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) { @@ -3143,19 +3145,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; @@ -3182,7 +3184,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 */ @@ -3224,6 +3226,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); @@ -3282,7 +3285,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) @@ -3290,6 +3293,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. */ @@ -3319,9 +3325,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 @@ -3335,7 +3341,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); @@ -3437,20 +3446,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; @@ -3482,7 +3491,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 */ @@ -3837,10 +3846,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; @@ -3860,12 +3869,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; @@ -3979,7 +3988,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; @@ -3995,9 +4004,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) { @@ -4099,7 +4110,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); } @@ -4918,13 +4929,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); @@ -4937,11 +4948,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); @@ -5023,7 +5034,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); @@ -5033,7 +5044,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 */ @@ -5046,7 +5057,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) { @@ -5327,7 +5338,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; @@ -5692,9 +5703,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; @@ -5720,7 +5731,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); @@ -5738,7 +5749,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); @@ -5827,7 +5838,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 @@ -6060,7 +6071,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); @@ -6077,6 +6088,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); @@ -6108,7 +6120,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) @@ -6116,6 +6128,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. @@ -6142,7 +6156,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); @@ -6298,9 +6315,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; @@ -6417,9 +6434,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) { @@ -7230,9 +7247,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) @@ -7256,9 +7273,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; @@ -7291,7 +7308,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; @@ -7319,7 +7336,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)); @@ -7898,9 +7915,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) @@ -7922,9 +7939,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; @@ -7981,7 +7998,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 */ @@ -8003,7 +8020,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; @@ -8031,7 +8047,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 */ @@ -8056,10 +8072,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)) { @@ -8067,7 +8081,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); @@ -8150,12 +8164,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; @@ -8403,12 +8417,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; @@ -8553,12 +8567,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);