Remove 'M' variants of lock macros
authorSimon Wilkinson <sxw@inf.ed.ac.uk>
Wed, 11 Nov 2009 08:32:48 +0000 (08:32 +0000)
committerDerrick Brashear <shadow|account-1000005@unknown>
Wed, 11 Nov 2009 17:15:25 +0000 (09:15 -0800)
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 <shadow@dementia.org>
Tested-by: Derrick Brashear <shadow@dementia.org>

24 files changed:
src/afs/AIX/osi_file.c
src/afs/DARWIN/osi_file.c
src/afs/FBSD/osi_file.c
src/afs/HPUX/osi_file.c
src/afs/IRIX/osi_file.c
src/afs/IRIX/osi_vnodeops.c
src/afs/LINUX/osi_file.c
src/afs/LINUX24/osi_file.c
src/afs/NBSD/osi_file.c
src/afs/OBSD/osi_file.c
src/afs/SOLARIS/osi_file.c
src/afs/afs_buffer.c
src/afs/afs_daemons.c
src/afs/afs_dcache.c
src/afs/afs_exporter.c
src/afs/afs_memcache.c
src/afs/afs_nfsclnt.c
src/afs/afs_osi_alloc.c
src/afs/afs_osi_vm.c
src/afs/afs_pioctl.c
src/afs/afs_segments.c
src/afs/afs_server.c
src/afs/afs_vcache.c
src/afs/lock.h

index c249158..ac0dcac 100644 (file)
@@ -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;
 }
 
index 70294fa..13067a7 100644 (file)
@@ -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;
 }
 
index 5ffb1a8..8dc9411 100644 (file)
@@ -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;
 }
 
index 5c944e3..14bd768 100644 (file)
@@ -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;
 }
 
index 23cc447..21e4b96 100644 (file)
@@ -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;
 }
 
index ebb64a1..7949115 100644 (file)
@@ -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 */
index 66ba7cf..378cda8 100644 (file)
@@ -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;
 }
 
index af86989..56959ea 100644 (file)
@@ -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;
 }
 
index 09db04b..312b9fd 100644 (file)
@@ -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;
 }
 
index b9c7b82..3cc2d1f 100644 (file)
@@ -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;
 }
 
index e484790..858d52a 100644 (file)
@@ -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;
 }
 
index b74c53c..d097637 100644 (file)
@@ -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;
 }
 
index db5f2a8..65dcd24 100644 (file)
@@ -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--;
        }
     }
index 5cb1182..3ba7120 100644 (file)
@@ -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) {
index 29be153..4b21711 100644 (file)
@@ -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;
 }
 
index 9105fcd..8853fa4 100644 (file)
@@ -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;
 }
 
index b350907..88ac622 100644 (file)
@@ -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);
 }
 
 
index 7b81436..bc0fa20 100644 (file)
@@ -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;
 }
 
index 29e2675..e1e24ab 100644 (file)
@@ -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 */
index a7585b1..467b381 100644 (file)
@@ -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++) {
index 2f1ba0c..04f5c9c 100644 (file)
@@ -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++) {
index 66b9813..6a8705e 100644 (file)
@@ -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);
index a68af8e..34afe69 100644 (file)
@@ -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 
index 02a7673..2aa5ea1 100644 (file)
@@ -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)