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();
astat->mtime = tvattr.va_mtime.tv_sec;
astat->atime = tvattr.va_atime.tv_sec;
}
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
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
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;
}
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);
astat->mtime = tvattr.va_mtime.tv_sec;
astat->atime = tvattr.va_atime.tv_sec;
}
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
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);
code = VOP_SETATTR(afile->vnode, &tvattr, &afs_osi_cred, current_proc());
#endif
AFS_GLOCK();
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
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);
astat->mtime = tvattr.va_mtime.tv_sec;
astat->atime = tvattr.va_atime.tv_sec;
}
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
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
#endif
if (glocked)
AFS_GLOCK();
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
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();
astat->mtime = tvattr.va_mtime.tv_sec;
astat->atime = tvattr.va_atime.tv_sec;
}
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
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
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;
}
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);
astat->mtime = tvattr.va_mtime.tv_sec;
astat->atime = tvattr.va_atime.tv_sec;
}
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
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;
}
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);
if (code) {
osi_Panic("VnodeToIno");
}
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return vattr.va_nodeid;
}
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);
if (code) {
osi_Panic("VnodeToDev");
}
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return (dev_t) vattr.va_fsid;
}
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);
if (code) {
osi_Panic("VnodeToSize");
}
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return vattr.va_size;
}
#endif /* 6.2 and dual fs cache */
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;
}
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);
up_write(&inode->i_alloc_sem);
#endif
AFS_GLOCK();
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
{
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;
astat->atime = OSIFILE_INODE(afile)->i_atime;
#endif
code = 0;
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
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);
up_write(&inode->i_alloc_sem);
#endif
AFS_GLOCK();
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
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();
astat->mtime = tvattr.va_mtime.tv_sec;
astat->atime = tvattr.va_atime.tv_sec;
}
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
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
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;
}
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();
astat->mtime = tvattr.va_mtime.tv_sec;
astat->atime = tvattr.va_atime.tv_sec;
}
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
if (code || tstat.size <= asize)
return code;
- MObtainWriteLock(&afs_xosi, 321);
+ ObtainWriteLock(&afs_xosi, 321);
VATTR_NULL(&tvattr);
tvattr.va_size = asize;
AFS_GUNLOCK();
AFS_GLOCK();
if (code == 0)
afile->size = asize;
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
* 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
if (code) {
osi_Panic("VnodeToSize");
}
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return (afs_int32) (vattr.va_size);
}
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();
astat->mtime = tvattr.va_mtime.tv_sec;
astat->atime = tvattr.va_atime.tv_sec;
}
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
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;
/*
code = VOP_SETATTR(afile->vnode, &tvattr, 0, &afs_osi_cred);
#endif
AFS_GLOCK();
- MReleaseWriteLock(&afs_xosi);
+ ReleaseWriteLock(&afs_xosi);
return code;
}
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);}
*/
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;
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
*/
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);
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;
}
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
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
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
DFlushBuffer(tb);
}
tb->lockers--;
- MReleaseWriteLock(&tb->lock);
- MObtainReadLock(&afs_bufferLock);
+ ReleaseWriteLock(&tb->lock);
+ ObtainReadLock(&afs_bufferLock);
}
}
- MReleaseReadLock(&afs_bufferLock);
+ ReleaseReadLock(&afs_bufferLock);
}
void *
/* 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 */
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;
}
{
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 */
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++) {
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--;
}
}
}
afs_nbrs++;
- MObtainWriteLock(&afs_xbrs, 302);
+ ObtainWriteLock(&afs_xbrs, 302);
while (1) {
int min_ts = 0;
struct brequest *min_tb = NULL;
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;
}
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);
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--;
}
}
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 */
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
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;
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;
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;
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;
AFS_STATCNT(afs_FreeDiscardedDCache);
- MObtainWriteLock(&afs_xdcache, 510);
+ ObtainWriteLock(&afs_xdcache, 510);
if (!afs_blocksDiscarded) {
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
return;
}
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
/*
* 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);
}
/*!
* 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) {
}
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
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) {
afs_PutDCache(tdc);
}
}
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
/*printf("Missing %d chunks\n", totalChunks);*/
* 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);
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 */
* 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)
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
} else {
if (dcLocked)
ReleaseSharedLock(&tdc->lock);
- MReleaseReadLock(&afs_xdcache);
+ ReleaseReadLock(&afs_xdcache);
}
if (!shortcut)
/* 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) {
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 */
}
#endif
osi_Panic("getdcache");
}
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
/*
* Locks held:
* avc->lock(R) if setLocks
tdc->dflags = DFEntryMod;
tdc->mflags = 0;
afs_MaybeWakeupTruncateDaemon();
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
ConvertWToSLock(&tdc->lock);
}
}
/* 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)
* 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];
QAdd(&DirtyQ, &tdc->dirty);
}
}
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
/*
* Now, for each dcache entry we found, check if it's dirty.
/* 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)
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
theader.version = AFS_CI_VERSION;
afs_osi_Write(afs_cacheInodep, 0, &theader, sizeof(theader));
}
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
}
/*
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) {
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;
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;
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;
}
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 */
} else
bytesRead = 0;
- MReleaseReadLock(&mceP->afs_memLock);
+ ReleaseReadLock(&mceP->afs_memLock);
return bytesRead;
}
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 */
} else
bytesRead = 0;
- MReleaseReadLock(&mceP->afs_memLock);
+ ReleaseReadLock(&mceP->afs_memLock);
return bytesRead;
}
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;
}
{
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;
}
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;
AFS_GLOCK();
mceP->size = (size + offset < mceP->size) ? mceP->size : size + offset;
- MReleaseWriteLock(&mceP->afs_memLock);
+ ReleaseWriteLock(&mceP->afs_memLock);
return size;
}
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;
mceP->size = (offset < mceP->size) ? mceP->size : offset;
AFS_GLOCK();
- MReleaseWriteLock(&mceP->afs_memLock);
+ ReleaseWriteLock(&mceP->afs_memLock);
return bytesWritten;
}
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;
if (AFS_UIO_OFFSET(uioP) > mceP->size)
mceP->size = AFS_UIO_OFFSET(uioP);
- MReleaseWriteLock(&mceP->afs_memLock);
+ ReleaseWriteLock(&mceP->afs_memLock);
return code;
}
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 {
if (size < mceP->size)
mceP->size = size;
- MReleaseWriteLock(&mceP->afs_memLock);
+ ReleaseWriteLock(&mceP->afs_memLock);
return 0;
}
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;
}
}
if (np->uid == NOPAG && np->host == host) {
np->refCount++;
np->lastcall = now;
- MReleaseWriteLock(&afs_xnfspag);
+ ReleaseWriteLock(&afs_xnfspag);
return np;
}
}
np->host = host;
np->refCount = 1;
np->lastcall = now;
- MReleaseWriteLock(&afs_xnfspag);
+ ReleaseWriteLock(&afs_xnfspag);
return np;
}
#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;
}
}
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;
}
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) {
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;
}
}
}
- MReleaseWriteLock(&afs_xnfspag);
+ ReleaseWriteLock(&afs_xnfspag);
}
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
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);
}
#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;
}
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;
}
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?
xrele(vp);
if (vp->v.v_flag & VTEXT) { /* still has a text object? */
- MReleaseWriteLock(&afs_ftf);
+ ReleaseWriteLock(&afs_ftf);
return;
}
}
/* finally, record that we've done it */
hset(vp->flushDV, fdv);
- MReleaseWriteLock(&afs_ftf);
+ ReleaseWriteLock(&afs_ftf);
}
#endif /* AFS_TEXT_ENV */
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 */
}
afs_PutDCache(tdc); /* bumped by getdslot */
}
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
ObtainReadLock(&afs_xvolume);
for (i = 0; i < NVOLS; i++) {
/* 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;) {
}
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".
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;) {
index = afs_dvnextTbl[index];
}
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
for (i = 0; i < j; i++) {
/* Iterate over the dcache entries we collected above */
* 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;) {
}
index = afs_dvnextTbl[index];
}
- MReleaseWriteLock(&afs_xdcache);
+ ReleaseWriteLock(&afs_xdcache);
for (i = 0; i < dcListCount; i++) {
tdc = dcList[i];
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;) {
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++) {
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);
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];
ReleaseReadLock(&afs_xserver);
if (lockit)
- MReleaseWriteLock(&afs_xvcb);
+ ReleaseWriteLock(&afs_xvcb);
afs_osi_Free(tfids, sizeof(struct AFSFid) * AFS_MAXCBRSCALL);
return 0;
}
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
done:
/* now release locks and return */
- MReleaseWriteLock(&afs_xvcb);
+ ReleaseWriteLock(&afs_xvcb);
return queued;
}
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];
}
}
- MReleaseWriteLock(&afs_xvcb);
+ ReleaseWriteLock(&afs_xvcb);
}
void
#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)
projects / packages / o / openafs.git / commitdiff