From bab6fd227f5724c4e4ca5d0ba1dc64e21ed21f97 Mon Sep 17 00:00:00 2001 From: Simon Wilkinson Date: Wed, 11 Nov 2009 08:32:48 +0000 Subject: [PATCH] Remove 'M' variants of lock macros Since the beginning, we've had M variants of the lock macros, which are identical to the normal form. Dispose of these variants, to make it clearer what's going on. Change-Id: I0b7708ec670ef0edb4c1dc21d472e5041d31f6a2 Reviewed-on: http://gerrit.openafs.org/807 Reviewed-by: Derrick Brashear Tested-by: Derrick Brashear --- src/afs/AIX/osi_file.c | 8 +-- src/afs/DARWIN/osi_file.c | 8 +-- src/afs/FBSD/osi_file.c | 8 +-- src/afs/HPUX/osi_file.c | 8 +-- src/afs/IRIX/osi_file.c | 8 +-- src/afs/IRIX/osi_vnodeops.c | 12 ++--- src/afs/LINUX/osi_file.c | 8 +-- src/afs/LINUX24/osi_file.c | 8 +-- src/afs/NBSD/osi_file.c | 8 +-- src/afs/OBSD/osi_file.c | 8 +-- src/afs/SOLARIS/osi_file.c | 12 ++--- src/afs/afs_buffer.c | 60 +++++++++++----------- src/afs/afs_daemons.c | 26 +++++----- src/afs/afs_dcache.c | 100 ++++++++++++++++++------------------ src/afs/afs_exporter.c | 10 ++-- src/afs/afs_memcache.c | 40 +++++++-------- src/afs/afs_nfsclnt.c | 24 ++++----- src/afs/afs_osi_alloc.c | 16 +++--- src/afs/afs_osi_vm.c | 6 +-- src/afs/afs_pioctl.c | 4 +- src/afs/afs_segments.c | 16 +++--- src/afs/afs_server.c | 2 +- src/afs/afs_vcache.c | 12 ++--- src/afs/lock.h | 11 ---- 24 files changed, 206 insertions(+), 217 deletions(-) diff --git a/src/afs/AIX/osi_file.c b/src/afs/AIX/osi_file.c index c249158e5..ac0dcac24 100644 --- a/src/afs/AIX/osi_file.c +++ b/src/afs/AIX/osi_file.c @@ -66,7 +66,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) register afs_int32 code; struct vattr tvattr; AFS_STATCNT(osi_Stat); - MObtainWriteLock(&afs_xosi, 320); + ObtainWriteLock(&afs_xosi, 320); AFS_GUNLOCK(); code = VNOP_GETATTR(afile->vnode, &tvattr, &afs_osi_cred); AFS_GLOCK(); @@ -75,7 +75,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) astat->mtime = tvattr.va_mtime.tv_sec; astat->atime = tvattr.va_atime.tv_sec; } - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } @@ -122,7 +122,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) code = afs_osi_Stat(afile, &tstat); if (code || tstat.size <= asize) return code; - MObtainWriteLock(&afs_xosi, 321); + ObtainWriteLock(&afs_xosi, 321); /* * If we're truncating an unopened file to a non-zero length, * we need to bind it to a vm segment @@ -134,7 +134,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) AFS_GUNLOCK(); code = VNOP_FTRUNC(afile->vnode, mode, asize, (caddr_t) 0, &afs_osi_cred); AFS_GLOCK(); - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } diff --git a/src/afs/DARWIN/osi_file.c b/src/afs/DARWIN/osi_file.c index 70294fa31..13067a748 100644 --- a/src/afs/DARWIN/osi_file.c +++ b/src/afs/DARWIN/osi_file.c @@ -214,7 +214,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) register afs_int32 code; struct vattr tvattr; AFS_STATCNT(osi_Stat); - MObtainWriteLock(&afs_xosi, 320); + ObtainWriteLock(&afs_xosi, 320); AFS_GUNLOCK(); #ifdef AFS_DARWIN80_ENV VATTR_INIT(&tvattr); @@ -234,7 +234,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) astat->mtime = tvattr.va_mtime.tv_sec; astat->atime = tvattr.va_atime.tv_sec; } - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } @@ -270,7 +270,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) code = afs_osi_Stat(afile, &tstat); if (code || tstat.size <= asize) return code; - MObtainWriteLock(&afs_xosi, 321); + ObtainWriteLock(&afs_xosi, 321); AFS_GUNLOCK(); #ifdef AFS_DARWIN80_ENV VATTR_INIT(&tvattr); @@ -282,7 +282,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) code = VOP_SETATTR(afile->vnode, &tvattr, &afs_osi_cred, current_proc()); #endif AFS_GLOCK(); - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } diff --git a/src/afs/FBSD/osi_file.c b/src/afs/FBSD/osi_file.c index 5ffb1a82b..8dc94113f 100644 --- a/src/afs/FBSD/osi_file.c +++ b/src/afs/FBSD/osi_file.c @@ -69,7 +69,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) register afs_int32 code; struct vattr tvattr; AFS_STATCNT(osi_Stat); - MObtainWriteLock(&afs_xosi, 320); + ObtainWriteLock(&afs_xosi, 320); AFS_GUNLOCK(); #if defined(AFS_FBSD80_ENV) vn_lock(afile->vnode, LK_EXCLUSIVE | LK_RETRY); @@ -88,7 +88,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) astat->mtime = tvattr.va_mtime.tv_sec; astat->atime = tvattr.va_atime.tv_sec; } - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } @@ -112,7 +112,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) register afs_int32 code, glocked; AFS_STATCNT(osi_Truncate); - MObtainWriteLock(&afs_xosi, 321); + ObtainWriteLock(&afs_xosi, 321); vp = afile->vnode; /* * This routine only shrinks files, and most systems @@ -153,7 +153,7 @@ out: #endif if (glocked) AFS_GLOCK(); - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } diff --git a/src/afs/HPUX/osi_file.c b/src/afs/HPUX/osi_file.c index 5c944e325..14bd7684d 100644 --- a/src/afs/HPUX/osi_file.c +++ b/src/afs/HPUX/osi_file.c @@ -67,7 +67,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) register afs_int32 code; struct vattr tvattr; AFS_STATCNT(osi_Stat); - MObtainWriteLock(&afs_xosi, 320); + ObtainWriteLock(&afs_xosi, 320); AFS_GUNLOCK(); code = VOP_GETATTR(afile->vnode, &tvattr, &afs_osi_cred, VSYNC); AFS_GLOCK(); @@ -76,7 +76,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) astat->mtime = tvattr.va_mtime.tv_sec; astat->atime = tvattr.va_atime.tv_sec; } - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } @@ -108,7 +108,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) code = afs_osi_Stat(afile, &tstat); if (code || tstat.size <= asize) return code; - MObtainWriteLock(&afs_xosi, 321); + ObtainWriteLock(&afs_xosi, 321); VATTR_NULL(&tvattr); /* note that this credential swapping stuff is only necessary because * of ufs's references directly to u.u_cred instead of to @@ -120,7 +120,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) code = VOP_SETATTR(afile->vnode, &tvattr, &afs_osi_cred, 0); AFS_GLOCK(); set_p_cred(u.u_procp, oldCred); /* restore */ - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } diff --git a/src/afs/IRIX/osi_file.c b/src/afs/IRIX/osi_file.c index 23cc44735..21e4b96cb 100644 --- a/src/afs/IRIX/osi_file.c +++ b/src/afs/IRIX/osi_file.c @@ -72,7 +72,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) register afs_int32 code; struct vattr tvattr; AFS_STATCNT(osi_Stat); - MObtainWriteLock(&afs_xosi, 320); + ObtainWriteLock(&afs_xosi, 320); AFS_GUNLOCK(); tvattr.va_mask = AT_SIZE | AT_BLKSIZE | AT_MTIME | AT_ATIME; AFS_VOP_GETATTR(afile->vnode, &tvattr, 0, &afs_osi_cred, code); @@ -82,7 +82,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) astat->mtime = tvattr.va_mtime.tv_sec; astat->atime = tvattr.va_atime.tv_sec; } - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } @@ -115,13 +115,13 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) code = afs_osi_Stat(afile, &tstat); if (code || tstat.size <= asize) return code; - MObtainWriteLock(&afs_xosi, 321); + ObtainWriteLock(&afs_xosi, 321); AFS_GUNLOCK(); tvattr.va_mask = AT_SIZE; tvattr.va_size = asize; AFS_VOP_SETATTR(afile->vnode, &tvattr, 0, &afs_osi_cred, code); AFS_GLOCK(); - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } diff --git a/src/afs/IRIX/osi_vnodeops.c b/src/afs/IRIX/osi_vnodeops.c index ebb64a19d..7949115ce 100644 --- a/src/afs/IRIX/osi_vnodeops.c +++ b/src/afs/IRIX/osi_vnodeops.c @@ -1937,7 +1937,7 @@ VnodeToIno(vnode_t * vp) int code; struct vattr vattr; - MObtainWriteLock(&afs_xosi, 579); + ObtainWriteLock(&afs_xosi, 579); vattr.va_mask = AT_FSID | AT_NODEID; /* quick return using this mask. */ AFS_GUNLOCK(); AFS_VOP_GETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code); @@ -1945,7 +1945,7 @@ VnodeToIno(vnode_t * vp) if (code) { osi_Panic("VnodeToIno"); } - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return vattr.va_nodeid; } @@ -1955,7 +1955,7 @@ VnodeToDev(vnode_t * vp) int code; struct vattr vattr; - MObtainWriteLock(&afs_xosi, 580); + ObtainWriteLock(&afs_xosi, 580); vattr.va_mask = AT_FSID | AT_NODEID; /* quick return using this mask. */ AFS_GUNLOCK(); AFS_VOP_GETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code); @@ -1963,7 +1963,7 @@ VnodeToDev(vnode_t * vp) if (code) { osi_Panic("VnodeToDev"); } - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return (dev_t) vattr.va_fsid; } @@ -1973,7 +1973,7 @@ VnodeToSize(vnode_t * vp) int code; struct vattr vattr; - MObtainWriteLock(&afs_xosi, 581); + ObtainWriteLock(&afs_xosi, 581); vattr.va_mask = AT_SIZE; AFS_GUNLOCK(); AFS_VOP_GETATTR(vp, &vattr, 0, OSI_GET_CURRENT_CRED(), code); @@ -1981,7 +1981,7 @@ VnodeToSize(vnode_t * vp) if (code) { osi_Panic("VnodeToSize"); } - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return vattr.va_size; } #endif /* 6.2 and dual fs cache */ diff --git a/src/afs/LINUX/osi_file.c b/src/afs/LINUX/osi_file.c index 66ba7cfac..378cda8a8 100644 --- a/src/afs/LINUX/osi_file.c +++ b/src/afs/LINUX/osi_file.c @@ -150,12 +150,12 @@ int afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) { AFS_STATCNT(osi_Stat); - MObtainWriteLock(&afs_xosi, 320); + ObtainWriteLock(&afs_xosi, 320); astat->size = i_size_read(OSIFILE_INODE(afile)); astat->mtime = OSIFILE_INODE(afile)->i_mtime.tv_sec; astat->atime = OSIFILE_INODE(afile)->i_atime.tv_sec; - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return 0; } @@ -189,7 +189,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) code = afs_osi_Stat(afile, &tstat); if (code || tstat.size <= asize) return code; - MObtainWriteLock(&afs_xosi, 321); + ObtainWriteLock(&afs_xosi, 321); AFS_GUNLOCK(); #ifdef STRUCT_INODE_HAS_I_ALLOC_SEM down_write(&inode->i_alloc_sem); @@ -229,7 +229,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) up_write(&inode->i_alloc_sem); #endif AFS_GLOCK(); - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } diff --git a/src/afs/LINUX24/osi_file.c b/src/afs/LINUX24/osi_file.c index af8698940..56959ea3a 100644 --- a/src/afs/LINUX24/osi_file.c +++ b/src/afs/LINUX24/osi_file.c @@ -206,7 +206,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) { register afs_int32 code; AFS_STATCNT(osi_Stat); - MObtainWriteLock(&afs_xosi, 320); + ObtainWriteLock(&afs_xosi, 320); astat->size = i_size_read(OSIFILE_INODE(afile)); #if defined(AFS_LINUX26_ENV) astat->mtime = OSIFILE_INODE(afile)->i_mtime.tv_sec; @@ -216,7 +216,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) astat->atime = OSIFILE_INODE(afile)->i_atime; #endif code = 0; - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } @@ -269,7 +269,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) code = afs_osi_Stat(afile, &tstat); if (code || tstat.size <= asize) return code; - MObtainWriteLock(&afs_xosi, 321); + ObtainWriteLock(&afs_xosi, 321); AFS_GUNLOCK(); #ifdef STRUCT_INODE_HAS_I_ALLOC_SEM down_write(&inode->i_alloc_sem); @@ -323,7 +323,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) up_write(&inode->i_alloc_sem); #endif AFS_GLOCK(); - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } diff --git a/src/afs/NBSD/osi_file.c b/src/afs/NBSD/osi_file.c index 09db04b03..312b9fd50 100644 --- a/src/afs/NBSD/osi_file.c +++ b/src/afs/NBSD/osi_file.c @@ -59,7 +59,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) register afs_int32 code; struct vattr tvattr; AFS_STATCNT(osi_Stat); - MObtainWriteLock(&afs_xosi, 320); + ObtainWriteLock(&afs_xosi, 320); AFS_GUNLOCK(); VOP_GETATTR(afile->vnode, &tvattr, afs_osi_credp, code); AFS_GLOCK(); @@ -68,7 +68,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) astat->mtime = tvattr.va_mtime.tv_sec; astat->atime = tvattr.va_atime.tv_sec; } - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } @@ -100,7 +100,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) code = afs_osi_Stat(afile, &tstat); if (code || tstat.size <= asize) return code; - MObtainWriteLock(&afs_xosi, 321); + ObtainWriteLock(&afs_xosi, 321); VATTR_NULL(&tvattr); /* note that this credential swapping stuff is only necessary because * of ufs's references directly to cred instead of to @@ -113,7 +113,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) VOP_SETATTR(afile->vnode, &tvattr, afs_osi_credp, code); AFS_GLOCK(); curproc->p_cred->pc_ucred = oldCred; /* restore */ - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } diff --git a/src/afs/OBSD/osi_file.c b/src/afs/OBSD/osi_file.c index b9c7b8275..3cc2d1f90 100644 --- a/src/afs/OBSD/osi_file.c +++ b/src/afs/OBSD/osi_file.c @@ -64,7 +64,7 @@ afs_osi_Stat(struct osi_file *afile, struct osi_stat *astat) struct vattr tvattr; AFS_STATCNT(osi_Stat); - MObtainWriteLock(&afs_xosi, 320); + ObtainWriteLock(&afs_xosi, 320); AFS_GUNLOCK(); code = VOP_GETATTR(afile->vnode, &tvattr, afs_osi_credp, curproc); AFS_GLOCK(); @@ -73,7 +73,7 @@ afs_osi_Stat(struct osi_file *afile, struct osi_stat *astat) astat->mtime = tvattr.va_mtime.tv_sec; astat->atime = tvattr.va_atime.tv_sec; } - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } @@ -107,7 +107,7 @@ osi_UFSTruncate(struct osi_file *afile, afs_int32 asize) if (code || tstat.size <= asize) return code; - MObtainWriteLock(&afs_xosi, 321); + ObtainWriteLock(&afs_xosi, 321); VATTR_NULL(&tvattr); tvattr.va_size = asize; AFS_GUNLOCK(); @@ -117,7 +117,7 @@ osi_UFSTruncate(struct osi_file *afile, afs_int32 asize) AFS_GLOCK(); if (code == 0) afile->size = asize; - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } diff --git a/src/afs/SOLARIS/osi_file.c b/src/afs/SOLARIS/osi_file.c index e48479010..858d52a2b 100644 --- a/src/afs/SOLARIS/osi_file.c +++ b/src/afs/SOLARIS/osi_file.c @@ -125,7 +125,7 @@ VnodeToSize(vnode_t * vp) * We lock xosi in osi_Stat, so we probably should * lock it here too - RWH. */ - MObtainWriteLock(&afs_xosi, 578); + ObtainWriteLock(&afs_xosi, 578); vattr.va_mask = AT_SIZE; AFS_GUNLOCK(); #ifdef AFS_SUN511_ENV @@ -137,7 +137,7 @@ VnodeToSize(vnode_t * vp) if (code) { osi_Panic("VnodeToSize"); } - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return (afs_int32) (vattr.va_size); } @@ -283,7 +283,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) register afs_int32 code; struct vattr tvattr; AFS_STATCNT(osi_Stat); - MObtainWriteLock(&afs_xosi, 320); + ObtainWriteLock(&afs_xosi, 320); /* Ufs doesn't seem to care about the flags so we pass 0 for now */ tvattr.va_mask = AT_ALL; AFS_GUNLOCK(); @@ -298,7 +298,7 @@ afs_osi_Stat(register struct osi_file *afile, register struct osi_stat *astat) astat->mtime = tvattr.va_mtime.tv_sec; astat->atime = tvattr.va_atime.tv_sec; } - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } @@ -330,7 +330,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) code = afs_osi_Stat(afile, &tstat); if (code || tstat.size <= asize) return code; - MObtainWriteLock(&afs_xosi, 321); + ObtainWriteLock(&afs_xosi, 321); tvattr.va_mask = AT_SIZE; tvattr.va_size = asize; /* @@ -347,7 +347,7 @@ osi_UFSTruncate(register struct osi_file *afile, afs_int32 asize) code = VOP_SETATTR(afile->vnode, &tvattr, 0, &afs_osi_cred); #endif AFS_GLOCK(); - MReleaseWriteLock(&afs_xosi); + ReleaseWriteLock(&afs_xosi); return code; } diff --git a/src/afs/afs_buffer.c b/src/afs/afs_buffer.c index b74c53cd7..d097637bd 100644 --- a/src/afs/afs_buffer.c +++ b/src/afs/afs_buffer.c @@ -170,7 +170,7 @@ DRead(register struct dcache *adc, register int page) int code; AFS_STATCNT(DRead); - MObtainWriteLock(&afs_bufferLock, 256); + ObtainWriteLock(&afs_bufferLock, 256); #define bufmatch(tb) (tb->page == page && tb->fid == adc->index) #define buf_Front(head,parent,p) {(parent)->hashNext = (p)->hashNext; (p)->hashNext= *(head);*(head)=(p);} @@ -183,12 +183,12 @@ DRead(register struct dcache *adc, register int page) */ if ((tb = phTable[pHash(adc->index, page)])) { if (bufmatch(tb)) { - MObtainWriteLock(&tb->lock, 257); + ObtainWriteLock(&tb->lock, 257); tb->lockers++; ReleaseWriteLock(&afs_bufferLock); tb->accesstime = timecounter++; AFS_STATS(afs_stats_cmperf.bufHits++); - MReleaseWriteLock(&tb->lock); + ReleaseWriteLock(&tb->lock); return tb->data; } else { register struct buffer **bufhead; @@ -196,23 +196,23 @@ DRead(register struct dcache *adc, register int page) while ((tb2 = tb->hashNext)) { if (bufmatch(tb2)) { buf_Front(bufhead, tb, tb2); - MObtainWriteLock(&tb2->lock, 258); + ObtainWriteLock(&tb2->lock, 258); tb2->lockers++; ReleaseWriteLock(&afs_bufferLock); tb2->accesstime = timecounter++; AFS_STATS(afs_stats_cmperf.bufHits++); - MReleaseWriteLock(&tb2->lock); + ReleaseWriteLock(&tb2->lock); return tb2->data; } if ((tb = tb2->hashNext)) { if (bufmatch(tb)) { buf_Front(bufhead, tb2, tb); - MObtainWriteLock(&tb->lock, 259); + ObtainWriteLock(&tb->lock, 259); tb->lockers++; ReleaseWriteLock(&afs_bufferLock); tb->accesstime = timecounter++; AFS_STATS(afs_stats_cmperf.bufHits++); - MReleaseWriteLock(&tb->lock); + ReleaseWriteLock(&tb->lock); return tb->data; } } else @@ -230,17 +230,17 @@ DRead(register struct dcache *adc, register int page) */ tb = afs_newslot(adc, page, (tb ? tb : tb2)); if (!tb) { - MReleaseWriteLock(&afs_bufferLock); + ReleaseWriteLock(&afs_bufferLock); return NULL; } - MObtainWriteLock(&tb->lock, 260); + ObtainWriteLock(&tb->lock, 260); tb->lockers++; - MReleaseWriteLock(&afs_bufferLock); + ReleaseWriteLock(&afs_bufferLock); if (page * AFS_BUFFER_PAGESIZE >= adc->f.chunkBytes) { tb->fid = NULLIDX; afs_reset_inode(&tb->inode); tb->lockers--; - MReleaseWriteLock(&tb->lock); + ReleaseWriteLock(&tb->lock); return NULL; } tfile = afs_CFileOpen(&adc->f.inode); @@ -252,12 +252,12 @@ DRead(register struct dcache *adc, register int page) tb->fid = NULLIDX; afs_reset_inode(&tb->inode); tb->lockers--; - MReleaseWriteLock(&tb->lock); + ReleaseWriteLock(&tb->lock); return NULL; } /* Note that findslot sets the page field in the buffer equal to * what it is searching for. */ - MReleaseWriteLock(&tb->lock); + ReleaseWriteLock(&tb->lock); return tb->data; } @@ -402,11 +402,11 @@ DRelease(void *loc, int flag) index = (((char *)bp) - ((char *)BufferData)) >> LOGPS; #endif bp = &(Buffers[index]); - MObtainWriteLock(&bp->lock, 261); + ObtainWriteLock(&bp->lock, 261); bp->lockers--; if (flag) bp->dirty = 1; - MReleaseWriteLock(&bp->lock); + ReleaseWriteLock(&bp->lock); } int @@ -460,18 +460,18 @@ DZap(struct dcache *adc) register struct buffer *tb; AFS_STATCNT(DZap); - MObtainReadLock(&afs_bufferLock); + ObtainReadLock(&afs_bufferLock); for (i = 0; i <= PHPAGEMASK; i++) for (tb = phTable[pHash(adc->index, i)]; tb; tb = tb->hashNext) if (tb->fid == adc->index) { - MObtainWriteLock(&tb->lock, 262); + ObtainWriteLock(&tb->lock, 262); tb->fid = NULLIDX; afs_reset_inode(&tb->inode); tb->dirty = 0; - MReleaseWriteLock(&tb->lock); + ReleaseWriteLock(&tb->lock); } - MReleaseReadLock(&afs_bufferLock); + ReleaseReadLock(&afs_bufferLock); } static void @@ -519,12 +519,12 @@ DFlush(void) AFS_STATCNT(DFlush); tb = Buffers; - MObtainReadLock(&afs_bufferLock); + ObtainReadLock(&afs_bufferLock); for (i = 0; i < nbuffers; i++, tb++) { if (tb->dirty) { - MObtainWriteLock(&tb->lock, 263); + ObtainWriteLock(&tb->lock, 263); tb->lockers++; - MReleaseReadLock(&afs_bufferLock); + ReleaseReadLock(&afs_bufferLock); if (tb->dirty) { /* it seems safe to do this I/O without having the dcache * locked, since the only things that will update the data in @@ -540,11 +540,11 @@ DFlush(void) DFlushBuffer(tb); } tb->lockers--; - MReleaseWriteLock(&tb->lock); - MObtainReadLock(&afs_bufferLock); + ReleaseWriteLock(&tb->lock); + ObtainReadLock(&afs_bufferLock); } } - MReleaseReadLock(&afs_bufferLock); + ReleaseReadLock(&afs_bufferLock); } void * @@ -553,9 +553,9 @@ DNew(register struct dcache *adc, register int page) /* Same as read, only do *not* even try to read the page, since it probably doesn't exist. */ register struct buffer *tb; AFS_STATCNT(DNew); - MObtainWriteLock(&afs_bufferLock, 264); + ObtainWriteLock(&afs_bufferLock, 264); if ((tb = afs_newslot(adc, page, NULL)) == 0) { - MReleaseWriteLock(&afs_bufferLock); + ReleaseWriteLock(&afs_bufferLock); return 0; } /* extend the chunk, if needed */ @@ -567,10 +567,10 @@ DNew(register struct dcache *adc, register int page) afs_AdjustSize(adc, (page + 1) * AFS_BUFFER_PAGESIZE); afs_WriteDCache(adc, 1); } - MObtainWriteLock(&tb->lock, 265); + ObtainWriteLock(&tb->lock, 265); tb->lockers++; - MReleaseWriteLock(&afs_bufferLock); - MReleaseWriteLock(&tb->lock); + ReleaseWriteLock(&afs_bufferLock); + ReleaseWriteLock(&tb->lock); return tb->data; } diff --git a/src/afs/afs_daemons.c b/src/afs/afs_daemons.c index db5f2a883..65dcd24a6 100644 --- a/src/afs/afs_daemons.c +++ b/src/afs/afs_daemons.c @@ -612,13 +612,13 @@ afs_BRelease(register struct brequest *ab) { AFS_STATCNT(afs_BRelease); - MObtainWriteLock(&afs_xbrs, 294); + ObtainWriteLock(&afs_xbrs, 294); if (--ab->refCount <= 0) { ab->flags = 0; } if (afs_brsWaiters) afs_osi_Wakeup(&afs_brsWaiters); - MReleaseWriteLock(&afs_xbrs); + ReleaseWriteLock(&afs_xbrs); } /* return true if bkg fetch daemons are all busy */ @@ -640,7 +640,7 @@ afs_BQueue(register short aopcode, register struct vcache *avc, register struct brequest *tb; AFS_STATCNT(afs_BQueue); - MObtainWriteLock(&afs_xbrs, 296); + ObtainWriteLock(&afs_xbrs, 296); while (1) { tb = afs_brs; for (i = 0; i < NBRS; i++, tb++) { @@ -667,18 +667,18 @@ afs_BQueue(register short aopcode, register struct vcache *avc, if (afs_brsDaemons > 0) { afs_osi_Wakeup(&afs_brsDaemons); } - MReleaseWriteLock(&afs_xbrs); + ReleaseWriteLock(&afs_xbrs); return tb; } if (dontwait) { - MReleaseWriteLock(&afs_xbrs); + ReleaseWriteLock(&afs_xbrs); return NULL; } /* no free buffers, sleep a while */ afs_brsWaiters++; - MReleaseWriteLock(&afs_xbrs); + ReleaseWriteLock(&afs_xbrs); afs_osi_Sleep(&afs_brsWaiters); - MObtainWriteLock(&afs_xbrs, 301); + ObtainWriteLock(&afs_xbrs, 301); afs_brsWaiters--; } } @@ -984,7 +984,7 @@ afs_BackgroundDaemon(void) } afs_nbrs++; - MObtainWriteLock(&afs_xbrs, 302); + ObtainWriteLock(&afs_xbrs, 302); while (1) { int min_ts = 0; struct brequest *min_tb = NULL; @@ -992,7 +992,7 @@ afs_BackgroundDaemon(void) if (afs_termState == AFSOP_STOP_BKG) { if (--afs_nbrs <= 0) afs_termState = AFSOP_STOP_TRUNCDAEMON; - MReleaseWriteLock(&afs_xbrs); + ReleaseWriteLock(&afs_xbrs); afs_osi_Wakeup(&afs_termState); return; } @@ -1013,7 +1013,7 @@ afs_BackgroundDaemon(void) if ((tb = min_tb)) { /* claim and process this request */ tb->flags |= BSTARTED; - MReleaseWriteLock(&afs_xbrs); + ReleaseWriteLock(&afs_xbrs); foundAny = 1; afs_Trace1(afs_iclSetp, CM_TRACE_BKG1, ICL_TYPE_INT32, tb->opcode); @@ -1038,14 +1038,14 @@ afs_BackgroundDaemon(void) tb->cred = (afs_ucred_t *)0; } afs_BRelease(tb); /* this grabs and releases afs_xbrs lock */ - MObtainWriteLock(&afs_xbrs, 305); + ObtainWriteLock(&afs_xbrs, 305); } if (!foundAny) { /* wait for new request */ afs_brsDaemons++; - MReleaseWriteLock(&afs_xbrs); + ReleaseWriteLock(&afs_xbrs); afs_osi_Sleep(&afs_brsDaemons); - MObtainWriteLock(&afs_xbrs, 307); + ObtainWriteLock(&afs_xbrs, 307); afs_brsDaemons--; } } diff --git a/src/afs/afs_dcache.c b/src/afs/afs_dcache.c index 5cb11827a..3ba712019 100644 --- a/src/afs/afs_dcache.c +++ b/src/afs/afs_dcache.c @@ -389,7 +389,7 @@ afs_CacheTruncateDaemon(void) afs_TruncateDaemonRunning = 1; while (1) { cb_lowat = PERCENT((CM_DCACHESPACEFREEPCT - CM_DCACHEEXTRAPCT), afs_cacheBlocks); - MObtainWriteLock(&afs_xdcache, 266); + ObtainWriteLock(&afs_xdcache, 266); if (afs_CacheTooFull) { int space_needed, slots_needed; /* if we get woken up, we should try to clean something out */ @@ -408,7 +408,7 @@ afs_CacheTruncateDaemon(void) if (!afs_CacheIsTooFull()) afs_CacheTooFull = 0; } /* end of cache cleanup */ - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); /* * This is a defensive check to try to avoid starving threads @@ -676,11 +676,11 @@ afs_GetDownD(int anumber, int *aneedSpace, afs_int32 buckethint) afs_size_t tchunkoffset = 0; afid = &tdc->f.fid; /* xdcache is lower than the xvcache lock */ - MReleaseWriteLock(&afs_xdcache); - MObtainReadLock(&afs_xvcache); + ReleaseWriteLock(&afs_xdcache); + ObtainReadLock(&afs_xvcache); tvc = afs_FindVCache(afid, 0, 0 /* no stats, no vlru */ ); - MReleaseReadLock(&afs_xvcache); - MObtainWriteLock(&afs_xdcache, 527); + ReleaseReadLock(&afs_xvcache); + ObtainWriteLock(&afs_xdcache, 527); skip = 0; if (tdc->refCount > 1) skip = 1; @@ -710,8 +710,8 @@ afs_GetDownD(int anumber, int *aneedSpace, afs_int32 buckethint) if (!skip && (chunkFlags & IFAnyPages)) { int code; - MReleaseWriteLock(&afs_xdcache); - MObtainWriteLock(&tvc->vlock, 543); + ReleaseWriteLock(&afs_xdcache); + ObtainWriteLock(&tvc->vlock, 543); if (tvc->multiPage) { skip = 1; goto endmultipage; @@ -720,31 +720,31 @@ afs_GetDownD(int anumber, int *aneedSpace, afs_int32 buckethint) tvc->vstates |= VPageCleaning; /* block getting new pages */ tvc->activeV++; - MReleaseWriteLock(&tvc->vlock); + ReleaseWriteLock(&tvc->vlock); /* One last recheck */ - MObtainWriteLock(&afs_xdcache, 333); + ObtainWriteLock(&afs_xdcache, 333); chunkFlags = afs_indexFlags[tdc->index]; if (tdc->refCount > 1 || (chunkFlags & IFDataMod) || (osi_Active(tvc) && (tvc->f.states & CDCLock) && (chunkFlags & IFAnyPages))) { skip = 1; - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); goto endputpage; } - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); code = osi_VM_GetDownD(tvc, tdc); - MObtainWriteLock(&afs_xdcache, 269); + ObtainWriteLock(&afs_xdcache, 269); /* we actually removed all pages, clean and dirty */ if (code == 0) { afs_indexFlags[tdc->index] &= ~(IFDirtyPages | IFAnyPages); } else skip = 1; - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); endputpage: - MObtainWriteLock(&tvc->vlock, 544); + ObtainWriteLock(&tvc->vlock, 544); if (--tvc->activeV == 0 && (tvc->vstates & VRevokeWait)) { tvc->vstates &= ~VRevokeWait; @@ -756,15 +756,15 @@ afs_GetDownD(int anumber, int *aneedSpace, afs_int32 buckethint) afs_osi_Wakeup((char *)&tvc->vstates); } endmultipage: - MReleaseWriteLock(&tvc->vlock); + ReleaseWriteLock(&tvc->vlock); } else #endif /* AFS_SUN5_ENV */ { - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); } afs_PutVCache(tvc); /*XXX was AFS_FAST_RELE?*/ - MObtainWriteLock(&afs_xdcache, 528); + ObtainWriteLock(&afs_xdcache, 528); if (afs_indexFlags[tdc->index] & (IFDataMod | IFDirtyPages | IFAnyPages)) skip = 1; @@ -1057,9 +1057,9 @@ afs_FreeDiscardedDCache(void) AFS_STATCNT(afs_FreeDiscardedDCache); - MObtainWriteLock(&afs_xdcache, 510); + ObtainWriteLock(&afs_xdcache, 510); if (!afs_blocksDiscarded) { - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); return; } @@ -1078,7 +1078,7 @@ afs_FreeDiscardedDCache(void) afs_stats_cmperf.cacheBlocksDiscarded = afs_blocksDiscarded; /* We can lock because we just took it off the free list */ ObtainWriteLock(&tdc->lock, 626); - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); /* * Truncate the element to reclaim its space @@ -1092,13 +1092,13 @@ afs_FreeDiscardedDCache(void) /* * Free the element we just truncated */ - MObtainWriteLock(&afs_xdcache, 511); + ObtainWriteLock(&afs_xdcache, 511); afs_indexFlags[tdc->index] &= ~IFDiscarded; afs_FreeDCache(tdc); tdc->f.states &= ~(DRO|DBackup|DRW); ReleaseWriteLock(&tdc->lock); afs_PutDCache(tdc); - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); } /*! @@ -1287,7 +1287,7 @@ afs_TryToSmush(register struct vcache *avc, afs_ucred_t *acred, int sync) * Get the hash chain containing all dce's for this fid */ i = DVHash(&avc->f.fid); - MObtainWriteLock(&afs_xdcache, 277); + ObtainWriteLock(&afs_xdcache, 277); for (index = afs_dvhashTbl[i]; index != NULLIDX; index = i) { i = afs_dvnextTbl[index]; /* next pointer this hash table */ if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) { @@ -1317,7 +1317,7 @@ afs_TryToSmush(register struct vcache *avc, afs_ucred_t *acred, int sync) } ReleaseWriteLock(&avc->vlock); #endif - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); /* * It's treated like a callback so that when we do lookups we'll * invalidate the unique bit if any @@ -1377,7 +1377,7 @@ afs_DCacheMissingChunks(struct vcache *avc) totalChunks, (totalLength + 1)); */ i = DVHash(&avc->f.fid); - MObtainWriteLock(&afs_xdcache, 1001); + ObtainWriteLock(&afs_xdcache, 1001); for (index = afs_dvhashTbl[i]; index != NULLIDX; index = i) { i = afs_dvnextTbl[index]; if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) { @@ -1389,7 +1389,7 @@ afs_DCacheMissingChunks(struct vcache *avc) afs_PutDCache(tdc); } } - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); /*printf("Missing %d chunks\n", totalChunks);*/ @@ -1431,7 +1431,7 @@ afs_FindDCache(register struct vcache *avc, afs_size_t abyte) * after write-locking the dcache. */ i = DCHash(&avc->f.fid, chunk); - MObtainWriteLock(&afs_xdcache, 278); + ObtainWriteLock(&afs_xdcache, 278); for (index = afs_dchashTbl[i]; index != NULLIDX;) { if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) { tdc = afs_GetDSlot(index, NULL); @@ -1446,10 +1446,10 @@ afs_FindDCache(register struct vcache *avc, afs_size_t abyte) if (index != NULLIDX) { hset(afs_indexTimes[tdc->index], afs_indexCounter); hadd32(afs_indexCounter, 1); - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); return tdc; } - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); return NULL; } /*afs_FindDCache */ @@ -1679,7 +1679,7 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte, * entries from the free list, and thereby assuming them to be not * referenced and not locked. */ - MObtainReadLock(&afs_xdcache); + ObtainReadLock(&afs_xdcache); dcLocked = (0 == NBObtainSharedLock(&tdc->lock, 601)); if (dcLocked && (tdc->index != NULLIDX) @@ -1695,17 +1695,17 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte, tdc->refCount++; ReleaseWriteLock(&tdc->tlock); - MReleaseReadLock(&afs_xdcache); + ReleaseReadLock(&afs_xdcache); shortcut = 1; if (hsame(tdc->f.versionNo, avc->f.m.DataVersion) && !(tdc->dflags & DFFetching)) { afs_stats_cmperf.dcacheHits++; - MObtainWriteLock(&afs_xdcache, 559); + ObtainWriteLock(&afs_xdcache, 559); QRemove(&tdc->lruq); QAdd(&afs_DLRU, &tdc->lruq); - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); /* Locks held: * avc->lock(R) if setLocks && !slowPass @@ -1717,7 +1717,7 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte, } else { if (dcLocked) ReleaseSharedLock(&tdc->lock); - MReleaseReadLock(&afs_xdcache); + ReleaseReadLock(&afs_xdcache); } if (!shortcut) @@ -1746,7 +1746,7 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte, /* check to make sure our space is fine */ afs_MaybeWakeupTruncateDaemon(); - MObtainWriteLock(&afs_xdcache, 280); + ObtainWriteLock(&afs_xdcache, 280); us = NULLIDX; for (index = afs_dchashTbl[i]; index != NULLIDX;) { if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) { @@ -1765,7 +1765,7 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte, afs_dcnextTbl[index] = afs_dchashTbl[i]; afs_dchashTbl[i] = index; } - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); ObtainSharedLock(&tdc->lock, 606); break; /* leaving refCount high for caller */ } @@ -1808,7 +1808,7 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte, #endif osi_Panic("getdcache"); } - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); /* * Locks held: * avc->lock(R) if setLocks @@ -1833,7 +1833,7 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte, tdc->dflags = DFEntryMod; tdc->mflags = 0; afs_MaybeWakeupTruncateDaemon(); - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); ConvertWToSLock(&tdc->lock); } } @@ -2358,10 +2358,10 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte, /* Fix up LRU info */ if (tdc) { - MObtainWriteLock(&afs_xdcache, 602); + ObtainWriteLock(&afs_xdcache, 602); hset(afs_indexTimes[tdc->index], afs_indexCounter); hadd32(afs_indexCounter, 1); - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); /* return the data */ if (vType(avc) == VDIR) @@ -2471,7 +2471,7 @@ afs_WriteThroughDSlots(void) * holding afs_xdcache. So we enter xdcache, get a reference * for every dcache entry, and exit xdcache. */ - MObtainWriteLock(&afs_xdcache, 283); + ObtainWriteLock(&afs_xdcache, 283); QInit(&DirtyQ); for (i = 0; i < afs_cacheFiles; i++) { tdc = afs_indexTable[i]; @@ -2485,7 +2485,7 @@ afs_WriteThroughDSlots(void) QAdd(&DirtyQ, &tdc->dirty); } } - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); /* * Now, for each dcache entry we found, check if it's dirty. @@ -2506,9 +2506,9 @@ afs_WriteThroughDSlots(void) /* Now that we have the write lock, double-check */ if (wrLock && (tdc->dflags & DFEntryMod)) { tdc->dflags &= ~DFEntryMod; - MObtainWriteLock(&afs_xdcache, 620); + ObtainWriteLock(&afs_xdcache, 620); afs_WriteDCache(tdc, 1); - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); touchedit = 1; } if (wrLock) @@ -2518,7 +2518,7 @@ afs_WriteThroughDSlots(void) afs_PutDCache(tdc); } - MObtainWriteLock(&afs_xdcache, 617); + ObtainWriteLock(&afs_xdcache, 617); if (!touchedit && (cacheDiskType != AFS_FCACHE_TYPE_MEM)) { /* Touch the file to make sure that the mtime on the file is kept * up-to-date to avoid losing cached files on cold starts because @@ -2532,7 +2532,7 @@ afs_WriteThroughDSlots(void) theader.version = AFS_CI_VERSION; afs_osi_Write(afs_cacheInodep, 0, &theader, sizeof(theader)); } - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); } /* @@ -2871,13 +2871,13 @@ afs_InitCacheFile(char *afile, ino_t ainode) if (index >= afs_cacheFiles) return EINVAL; - MObtainWriteLock(&afs_xdcache, 282); + ObtainWriteLock(&afs_xdcache, 282); tdc = afs_GetDSlot(index, NULL); ReleaseReadLock(&tdc->tlock); - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); ObtainWriteLock(&tdc->lock, 621); - MObtainWriteLock(&afs_xdcache, 622); + ObtainWriteLock(&afs_xdcache, 622); if (afile) { code = afs_LookupInodeByPath(afile, &tdc->f.inode.ufs, NULL); if (code) { diff --git a/src/afs/afs_exporter.c b/src/afs/afs_exporter.c index 29be15328..4b217116e 100644 --- a/src/afs/afs_exporter.c +++ b/src/afs/afs_exporter.c @@ -37,7 +37,7 @@ exporter_add(afs_int32 size, struct exporterops *ops, afs_int32 state, length = (size ? size : sizeof(struct afs_exporter)); ex = (struct afs_exporter *)afs_osi_Alloc(length); memset(ex, 0, length); - MObtainWriteLock(&afs_xexp, 308); + ObtainWriteLock(&afs_xexp, 308); for (op = root_exported; op; op = op->exp_next) { if (!op->exp_next) break; @@ -46,7 +46,7 @@ exporter_add(afs_int32 size, struct exporterops *ops, afs_int32 state, op->exp_next = ex; else root_exported = ex; - MReleaseWriteLock(&afs_xexp); + ReleaseWriteLock(&afs_xexp); ex->exp_next = 0; ex->exp_op = ops; ex->exp_states = state; @@ -63,14 +63,14 @@ exporter_find(int type) struct afs_exporter *op; AFS_STATCNT(exporter_add); - MObtainReadLock(&afs_xexp); + ObtainReadLock(&afs_xexp); for (op = root_exported; op; op = op->exp_next) { if (op->exp_type == type) { - MReleaseReadLock(&afs_xexp); + ReleaseReadLock(&afs_xexp); return op; } } - MReleaseReadLock(&afs_xexp); + ReleaseReadLock(&afs_xexp); return (struct afs_exporter *)0; } diff --git a/src/afs/afs_memcache.c b/src/afs/afs_memcache.c index 9105fcd85..8853fa497 100644 --- a/src/afs/afs_memcache.c +++ b/src/afs/afs_memcache.c @@ -104,10 +104,10 @@ afs_MemReadBlk(register struct osi_file *fP, int offset, void *dest, register struct memCacheEntry *mceP = (struct memCacheEntry *)fP; int bytesRead; - MObtainReadLock(&mceP->afs_memLock); + ObtainReadLock(&mceP->afs_memLock); AFS_STATCNT(afs_MemReadBlk); if (offset < 0) { - MReleaseReadLock(&mceP->afs_memLock); + ReleaseReadLock(&mceP->afs_memLock); return 0; } /* use min of bytes in buffer or requested size */ @@ -120,7 +120,7 @@ afs_MemReadBlk(register struct osi_file *fP, int offset, void *dest, } else bytesRead = 0; - MReleaseReadLock(&mceP->afs_memLock); + ReleaseReadLock(&mceP->afs_memLock); return bytesRead; } @@ -135,10 +135,10 @@ afs_MemReadvBlk(register struct memCacheEntry *mceP, int offset, int bytesRead; int bytesToRead; - MObtainReadLock(&mceP->afs_memLock); + ObtainReadLock(&mceP->afs_memLock); AFS_STATCNT(afs_MemReadBlk); if (offset < 0) { - MReleaseReadLock(&mceP->afs_memLock); + ReleaseReadLock(&mceP->afs_memLock); return 0; } /* use min of bytes in buffer or requested size */ @@ -157,7 +157,7 @@ afs_MemReadvBlk(register struct memCacheEntry *mceP, int offset, } else bytesRead = 0; - MReleaseReadLock(&mceP->afs_memLock); + ReleaseReadLock(&mceP->afs_memLock); return bytesRead; } @@ -170,10 +170,10 @@ afs_MemReadUIO(afs_dcache_id_t *ainode, struct uio *uioP) afs_int32 code; AFS_STATCNT(afs_MemReadUIO); - MObtainReadLock(&mceP->afs_memLock); + ObtainReadLock(&mceP->afs_memLock); length = (length < AFS_UIO_RESID(uioP)) ? length : AFS_UIO_RESID(uioP); AFS_UIOMOVE(mceP->data + AFS_UIO_OFFSET(uioP), length, UIO_READ, uioP, code); - MReleaseReadLock(&mceP->afs_memLock); + ReleaseReadLock(&mceP->afs_memLock); return code; } @@ -184,7 +184,7 @@ afs_MemWriteBlk(register struct osi_file *fP, int offset, void *src, { register struct memCacheEntry *mceP = (struct memCacheEntry *)fP; AFS_STATCNT(afs_MemWriteBlk); - MObtainWriteLock(&mceP->afs_memLock, 560); + ObtainWriteLock(&mceP->afs_memLock, 560); if (size + offset > mceP->dataSize) { char *oldData = mceP->data; @@ -195,7 +195,7 @@ afs_MemWriteBlk(register struct osi_file *fP, int offset, void *src, } if (mceP->data == NULL) { /* no available memory */ mceP->data = oldData; /* revert back change that was made */ - MReleaseWriteLock(&mceP->afs_memLock); + ReleaseWriteLock(&mceP->afs_memLock); afs_warn("afs: afs_MemWriteBlk mem alloc failure (%d bytes)\n", size + offset); return -ENOMEM; @@ -215,7 +215,7 @@ afs_MemWriteBlk(register struct osi_file *fP, int offset, void *src, AFS_GLOCK(); mceP->size = (size + offset < mceP->size) ? mceP->size : size + offset; - MReleaseWriteLock(&mceP->afs_memLock); + ReleaseWriteLock(&mceP->afs_memLock); return size; } @@ -228,14 +228,14 @@ afs_MemWritevBlk(register struct memCacheEntry *mceP, int offset, int bytesWritten; int bytesToWrite; AFS_STATCNT(afs_MemWriteBlk); - MObtainWriteLock(&mceP->afs_memLock, 561); + ObtainWriteLock(&mceP->afs_memLock, 561); if (offset + size > mceP->dataSize) { char *oldData = mceP->data; mceP->data = afs_osi_Alloc(size + offset); if (mceP->data == NULL) { /* no available memory */ mceP->data = oldData; /* revert back change that was made */ - MReleaseWriteLock(&mceP->afs_memLock); + ReleaseWriteLock(&mceP->afs_memLock); afs_warn("afs: afs_MemWriteBlk mem alloc failure (%d bytes)\n", size + offset); return -ENOMEM; @@ -261,7 +261,7 @@ afs_MemWritevBlk(register struct memCacheEntry *mceP, int offset, mceP->size = (offset < mceP->size) ? mceP->size : offset; AFS_GLOCK(); - MReleaseWriteLock(&mceP->afs_memLock); + ReleaseWriteLock(&mceP->afs_memLock); return bytesWritten; } @@ -273,14 +273,14 @@ afs_MemWriteUIO(afs_dcache_id_t *ainode, struct uio *uioP) afs_int32 code; AFS_STATCNT(afs_MemWriteUIO); - MObtainWriteLock(&mceP->afs_memLock, 312); + ObtainWriteLock(&mceP->afs_memLock, 312); if (AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP) > mceP->dataSize) { char *oldData = mceP->data; mceP->data = afs_osi_Alloc(AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP)); if (mceP->data == NULL) { /* no available memory */ mceP->data = oldData; /* revert back change that was made */ - MReleaseWriteLock(&mceP->afs_memLock); + ReleaseWriteLock(&mceP->afs_memLock); afs_warn("afs: afs_MemWriteBlk mem alloc failure (%d bytes)\n", AFS_UIO_RESID(uioP) + AFS_UIO_OFFSET(uioP)); return -ENOMEM; @@ -301,7 +301,7 @@ afs_MemWriteUIO(afs_dcache_id_t *ainode, struct uio *uioP) if (AFS_UIO_OFFSET(uioP) > mceP->size) mceP->size = AFS_UIO_OFFSET(uioP); - MReleaseWriteLock(&mceP->afs_memLock); + ReleaseWriteLock(&mceP->afs_memLock); return code; } @@ -311,14 +311,14 @@ afs_MemCacheTruncate(register struct osi_file *fP, int size) register struct memCacheEntry *mceP = (struct memCacheEntry *)fP; AFS_STATCNT(afs_MemCacheTruncate); - MObtainWriteLock(&mceP->afs_memLock, 313); + ObtainWriteLock(&mceP->afs_memLock, 313); /* old directory entry; g.c. */ if (size == 0 && mceP->dataSize > memCacheBlkSize) { char *oldData = mceP->data; mceP->data = afs_osi_Alloc(memCacheBlkSize); if (mceP->data == NULL) { /* no available memory */ mceP->data = oldData; - MReleaseWriteLock(&mceP->afs_memLock); + ReleaseWriteLock(&mceP->afs_memLock); afs_warn("afs: afs_MemWriteBlk mem alloc failure (%d bytes)\n", memCacheBlkSize); } else { @@ -330,7 +330,7 @@ afs_MemCacheTruncate(register struct osi_file *fP, int size) if (size < mceP->size) mceP->size = size; - MReleaseWriteLock(&mceP->afs_memLock); + ReleaseWriteLock(&mceP->afs_memLock); return 0; } diff --git a/src/afs/afs_nfsclnt.c b/src/afs/afs_nfsclnt.c index b350907f0..88ac62253 100644 --- a/src/afs/afs_nfsclnt.c +++ b/src/afs/afs_nfsclnt.c @@ -58,12 +58,12 @@ afs_GetNfsClientPag(register afs_int32 uid, register afs_int32 host) AFS_STATCNT(afs_GetNfsClientPag); i = NHash(host); now = osi_Time(); - MObtainWriteLock(&afs_xnfspag, 314); + ObtainWriteLock(&afs_xnfspag, 314); for (np = afs_nfspags[i]; np; np = np->next) { if (np->uid == uid && np->host == host) { np->refCount++; np->lastcall = now; - MReleaseWriteLock(&afs_xnfspag); + ReleaseWriteLock(&afs_xnfspag); return np; } } @@ -72,7 +72,7 @@ afs_GetNfsClientPag(register afs_int32 uid, register afs_int32 host) if (np->uid == NOPAG && np->host == host) { np->refCount++; np->lastcall = now; - MReleaseWriteLock(&afs_xnfspag); + ReleaseWriteLock(&afs_xnfspag); return np; } } @@ -86,7 +86,7 @@ afs_GetNfsClientPag(register afs_int32 uid, register afs_int32 host) np->host = host; np->refCount = 1; np->lastcall = now; - MReleaseWriteLock(&afs_xnfspag); + ReleaseWriteLock(&afs_xnfspag); return np; } @@ -119,13 +119,13 @@ afs_FindNfsClientPag(afs_int32 uid, afs_int32 host, afs_int32 pag) #endif AFS_STATCNT(afs_FindNfsClientPag); i = NHash(host); - MObtainWriteLock(&afs_xnfspag, 315); + ObtainWriteLock(&afs_xnfspag, 315); for (np = afs_nfspags[i]; np; np = np->next) { if (np->host == host) { if ((pag && pag == np->pag) || (!pag && (uid == np->uid))) { np->refCount++; np->lastcall = osi_Time(); - MReleaseWriteLock(&afs_xnfspag); + ReleaseWriteLock(&afs_xnfspag); return np; } } @@ -136,12 +136,12 @@ afs_FindNfsClientPag(afs_int32 uid, afs_int32 host, afs_int32 pag) if (np->uid == NOPAG) { np->refCount++; np->lastcall = osi_Time(); - MReleaseWriteLock(&afs_xnfspag); + ReleaseWriteLock(&afs_xnfspag); return np; } } } - MReleaseWriteLock(&afs_xnfspag); + ReleaseWriteLock(&afs_xnfspag); return NULL; } @@ -466,12 +466,12 @@ afs_nfsclient_sysname(register struct nfsclientpag *np, char *inname, if (allpags > 0) { /* update every client, not just the one making the request */ i = NHash(np->host); - MObtainWriteLock(&afs_xnfspag, 315); + ObtainWriteLock(&afs_xnfspag, 315); for (tnp = afs_nfspags[i]; tnp; tnp = tnp->next) { if (tnp != np && tnp->host == np->host) afs_nfsclient_sysname(tnp, inname, outname, num, -1); } - MReleaseWriteLock(&afs_xnfspag); + ReleaseWriteLock(&afs_xnfspag); } if (inname) { for(count=0; count < np->sysnamecount;++count) { @@ -514,7 +514,7 @@ afs_nfsclient_GC(exporter, pag) osi_Assert(ISAFS_GLOCK()); #endif AFS_STATCNT(afs_nfsclient_GC); - MObtainWriteLock(&afs_xnfspag, 316); + ObtainWriteLock(&afs_xnfspag, 316); for (i = 0; i < NNFSCLIENTS; i++) { for (tnp = &afs_nfspags[i], np = *tnp; np; np = nnp) { nnp = np->next; @@ -533,7 +533,7 @@ afs_nfsclient_GC(exporter, pag) } } } - MReleaseWriteLock(&afs_xnfspag); + ReleaseWriteLock(&afs_xnfspag); } diff --git a/src/afs/afs_osi_alloc.c b/src/afs/afs_osi_alloc.c index 7b81436d4..bc0fa20fa 100644 --- a/src/afs/afs_osi_alloc.c +++ b/src/afs/afs_osi_alloc.c @@ -137,10 +137,10 @@ osi_FreeLargeSpace(void *adata) AFS_STATCNT(osi_FreeLargeSpace); afs_stats_cmperf.LargeBlocksActive--; - MObtainWriteLock(&osi_flplock, 322); + ObtainWriteLock(&osi_flplock, 322); ((struct osi_packet *)adata)->next = freePacketList; freePacketList = adata; - MReleaseWriteLock(&osi_flplock); + ReleaseWriteLock(&osi_flplock); } void @@ -151,10 +151,10 @@ osi_FreeSmallSpace(void *adata) AFS_STATCNT(osi_FreeSmallSpace); afs_stats_cmperf.SmallBlocksActive--; - MObtainWriteLock(&osi_fsplock, 323); + ObtainWriteLock(&osi_fsplock, 323); ((struct osi_packet *)adata)->next = freeSmallList; freeSmallList = adata; - MReleaseWriteLock(&osi_fsplock); + ReleaseWriteLock(&osi_fsplock); } @@ -185,11 +185,11 @@ osi_AllocLargeSpace(size_t size) #endif return p; } - MObtainWriteLock(&osi_flplock, 324); + ObtainWriteLock(&osi_flplock, 324); tp = freePacketList; if (tp) freePacketList = tp->next; - MReleaseWriteLock(&osi_flplock); + ReleaseWriteLock(&osi_flplock); return (char *)tp; } @@ -214,11 +214,11 @@ osi_AllocSmallSpace(size_t size) return (char *)tp; } afs_stats_cmperf.SmallBlocksActive++; - MObtainWriteLock(&osi_fsplock, 327); + ObtainWriteLock(&osi_fsplock, 327); tp = freeSmallList; if (tp) freeSmallList = tp->next; - MReleaseWriteLock(&osi_fsplock); + ReleaseWriteLock(&osi_fsplock); return (char *)tp; } diff --git a/src/afs/afs_osi_vm.c b/src/afs/afs_osi_vm.c index 29e2675fe..e1e24ab23 100644 --- a/src/afs/afs_osi_vm.c +++ b/src/afs/afs_osi_vm.c @@ -130,7 +130,7 @@ osi_FlushText_really(register struct vcache *vp) if (hcmp(vp->f.m.DataVersion, vp->flushDV) <= 0) return; - MObtainWriteLock(&afs_ftf, 317); + ObtainWriteLock(&afs_ftf, 317); hset(fdv, vp->f.m.DataVersion); /* why this disgusting code below? @@ -159,7 +159,7 @@ osi_FlushText_really(register struct vcache *vp) xrele(vp); if (vp->v.v_flag & VTEXT) { /* still has a text object? */ - MReleaseWriteLock(&afs_ftf); + ReleaseWriteLock(&afs_ftf); return; } } @@ -170,7 +170,7 @@ osi_FlushText_really(register struct vcache *vp) /* finally, record that we've done it */ hset(vp->flushDV, fdv); - MReleaseWriteLock(&afs_ftf); + ReleaseWriteLock(&afs_ftf); } #endif /* AFS_TEXT_ENV */ diff --git a/src/afs/afs_pioctl.c b/src/afs/afs_pioctl.c index a7585b106..467b3819c 100644 --- a/src/afs/afs_pioctl.c +++ b/src/afs/afs_pioctl.c @@ -3032,7 +3032,7 @@ DECL_PIOCTL(PFlushVolumeData) ReleaseReadLock(&afs_xvcache); - MObtainWriteLock(&afs_xdcache, 328); /* needed if you're going to flush any stuff */ + ObtainWriteLock(&afs_xdcache, 328); /* needed if you're going to flush any stuff */ for (i = 0; i < afs_cacheFiles; i++) { if (!(afs_indexFlags[i] & IFEverUsed)) continue; /* never had any data */ @@ -3056,7 +3056,7 @@ DECL_PIOCTL(PFlushVolumeData) } afs_PutDCache(tdc); /* bumped by getdslot */ } - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); ObtainReadLock(&afs_xvolume); for (i = 0; i < NVOLS; i++) { diff --git a/src/afs/afs_segments.c b/src/afs/afs_segments.c index 2f1ba0c7a..04f5c9c00 100644 --- a/src/afs/afs_segments.c +++ b/src/afs/afs_segments.c @@ -244,7 +244,7 @@ afs_StoreAllSegments(register struct vcache *avc, struct vrequest *areq, /* lock and start over from beginning of hash chain * in order to avoid a race condition. */ - MObtainWriteLock(&afs_xdcache, 284); + ObtainWriteLock(&afs_xdcache, 284); index = afs_dvhashTbl[hash]; for (j = 0; index != NULLIDX;) { @@ -282,7 +282,7 @@ afs_StoreAllSegments(register struct vcache *avc, struct vrequest *areq, } index = afs_dvnextTbl[index]; } - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); /* this guy writes chunks, puts back dcache structs, and bumps newDV */ /* "moredata" just says "there are more dirty chunks yet to come". @@ -343,7 +343,7 @@ afs_StoreAllSegments(register struct vcache *avc, struct vrequest *areq, NCHUNKSATONCE * sizeof(struct dcache *)); /* overkill, but it gets the lock in case GetDSlot needs it */ - MObtainWriteLock(&afs_xdcache, 285); + ObtainWriteLock(&afs_xdcache, 285); for (j = 0, safety = 0, index = afs_dvhashTbl[hash]; index != NULLIDX && safety < afs_cacheFiles + 2;) { @@ -374,7 +374,7 @@ afs_StoreAllSegments(register struct vcache *avc, struct vrequest *areq, index = afs_dvnextTbl[index]; } - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); for (i = 0; i < j; i++) { /* Iterate over the dcache entries we collected above */ @@ -508,7 +508,7 @@ afs_InvalidateAllSegments(struct vcache *avc) * Block out others from screwing with this table; is a read lock * sufficient? */ - MObtainWriteLock(&afs_xdcache, 286); + ObtainWriteLock(&afs_xdcache, 286); dcListMax = 0; for (index = afs_dvhashTbl[hash]; index != NULLIDX;) { @@ -547,7 +547,7 @@ afs_InvalidateAllSegments(struct vcache *avc) } index = afs_dvnextTbl[index]; } - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); for (i = 0; i < dcListCount; i++) { tdc = dcList[i]; @@ -699,7 +699,7 @@ afs_TruncateAllSegments(register struct vcache *avc, afs_size_t alen, code = DVHash(&avc->f.fid); /* block out others from screwing with this table */ - MObtainWriteLock(&afs_xdcache, 287); + ObtainWriteLock(&afs_xdcache, 287); dcCount = 0; for (index = afs_dvhashTbl[code]; index != NULLIDX;) { @@ -738,7 +738,7 @@ afs_TruncateAllSegments(register struct vcache *avc, afs_size_t alen, index = afs_dvnextTbl[index]; } - MReleaseWriteLock(&afs_xdcache); + ReleaseWriteLock(&afs_xdcache); /* Now we loop over the array of dcache entries and truncate them */ for (index = 0; index < dcPos; index++) { diff --git a/src/afs/afs_server.c b/src/afs/afs_server.c index 66b98138d..6a8705e83 100644 --- a/src/afs/afs_server.c +++ b/src/afs/afs_server.c @@ -1560,7 +1560,7 @@ void afs_FlushServer(struct server *srvp) { if (srvp->cbrs) { struct afs_cbr *cb, *cbnext; - MObtainWriteLock(&afs_xvcb, 300); + ObtainWriteLock(&afs_xvcb, 300); for (cb = srvp->cbrs; cb; cb = cbnext) { cbnext = cb->next; afs_FreeCBR(cb); diff --git a/src/afs/afs_vcache.c b/src/afs/afs_vcache.c index a68af8e31..34afe69de 100644 --- a/src/afs/afs_vcache.c +++ b/src/afs/afs_vcache.c @@ -386,7 +386,7 @@ afs_FlushVCBs(afs_int32 lockit) tfids = afs_osi_Alloc(sizeof(struct AFSFid) * AFS_MAXCBRSCALL); if (lockit) - MObtainWriteLock(&afs_xvcb, 273); + ObtainWriteLock(&afs_xvcb, 273); ObtainReadLock(&afs_xserver); for (i = 0; i < NSERVERS; i++) { for (safety1 = 0, tsp = afs_servers[i]; @@ -471,7 +471,7 @@ afs_FlushVCBs(afs_int32 lockit) ReleaseReadLock(&afs_xserver); if (lockit) - MReleaseWriteLock(&afs_xvcb); + ReleaseWriteLock(&afs_xvcb); afs_osi_Free(tfids, sizeof(struct AFSFid) * AFS_MAXCBRSCALL); return 0; } @@ -496,7 +496,7 @@ afs_QueueVCB(struct vcache *avc) AFS_STATCNT(afs_QueueVCB); - MObtainWriteLock(&afs_xvcb, 274); + ObtainWriteLock(&afs_xvcb, 274); /* we can't really give back callbacks on RO files, since the * server only tracks them on a per-volume basis, and we don't @@ -527,7 +527,7 @@ afs_QueueVCB(struct vcache *avc) done: /* now release locks and return */ - MReleaseWriteLock(&afs_xvcb); + ReleaseWriteLock(&afs_xvcb); return queued; } @@ -551,7 +551,7 @@ afs_RemoveVCB(struct VenusFid *afid) struct afs_cbr *cbr, *ncbr; AFS_STATCNT(afs_RemoveVCB); - MObtainWriteLock(&afs_xvcb, 275); + ObtainWriteLock(&afs_xvcb, 275); slot = afs_HashCBRFid(&afid->Fid); ncbr = afs_cbrHashT[slot]; @@ -567,7 +567,7 @@ afs_RemoveVCB(struct VenusFid *afid) } } - MReleaseWriteLock(&afs_xvcb); + ReleaseWriteLock(&afs_xvcb); } void diff --git a/src/afs/lock.h b/src/afs/lock.h index 02a76734e..2aa5ea1d8 100644 --- a/src/afs/lock.h +++ b/src/afs/lock.h @@ -52,17 +52,6 @@ typedef struct afs_bozoLock afs_bozoLock_t; #define AFS_BOZONWAITING 1 /* someone is waiting for this lock */ -#undef MObtainWriteLock /* Defined also in ../rx/rx_machdep.h" */ -#undef MReleaseWriteLock -#define MObtainReadLock(lock) ObtainReadLock(lock) -#define MObtainWriteLock(lock,src) ObtainWriteLock(lock,src) -#define MObtainSharedLock(lock,src) ObtainSharedLock(lock,src) -#define MUpgradeSToWLock(lock,src) UpgradeSToWLock(lock,src) -#define MConvertWToSLock(lock) ConvertWToSLock(lock) -#define MReleaseReadLock(lock) ReleaseReadLock(lock) -#define MReleaseWriteLock(lock) ReleaseWriteLock(lock) -#define MReleaseSharedLock(lock) ReleaseSharedLock(lock) - #define AFS_RWLOCK_INIT(lock, nm) Lock_Init(lock) #undef LOCK_INIT #define LOCK_INIT(lock, nm) Lock_Init(lock) -- 2.39.5