#endif
tb->hashIndex = 0;
tb->dirty = 0;
- RWLOCK_INIT(&tb->lock, "buffer lock");
+ AFS_RWLOCK_INIT(&tb->lock, "buffer lock");
}
return;
}
MReleaseWriteLock(&tb->lock);
return NULL;
}
+#if defined(LINUX_USE_FH)
+ tfile = afs_CFileOpen(&adc->f.fh, adc->f.fh_type);
+#else
tfile = afs_CFileOpen(adc->f.inode);
+#endif
code =
afs_CFileRead(tfile, tb->page * AFS_BUFFER_PAGESIZE, tb->data,
AFS_BUFFER_PAGESIZE);
if (lp->dirty) {
/* see DFlush for rationale for not getting and locking the dcache */
- tfile = afs_CFileOpen(lp->inode);
+#if defined(LINUX_USE_FH)
+ tfile = afs_CFileOpen(&lp->fh, lp->fh_type);
+#else
+ tfile = afs_CFileOpen(lp->inode);
+#endif
afs_CFileWrite(tfile, lp->page * AFS_BUFFER_PAGESIZE, lp->data,
AFS_BUFFER_PAGESIZE);
lp->dirty = 0;
/* Now fill in the header. */
lp->fid = adc->index;
+#if defined(LINUX_USE_FH)
+ memcpy(&lp->fh, &adc->f.fh, sizeof(struct fid));
+ lp->fh_type = adc->f.fh_type;
+#else
lp->inode = adc->f.inode;
+#endif
lp->page = apage;
lp->accesstime = timecounter++;
FixupBucket(lp); /* move to the right hash bucket */
return AFS_BUFFER_PAGESIZE * bp->page + (int)(((char *)ap) - bp->data);
}
-/* 1/1/91 - I've modified the hash function to take the page as well
+/*!
+ * Zap one dcache entry: destroy one FID's buffers.
+ *
+ * 1/1/91 - I've modified the hash function to take the page as well
* as the *fid, so that lookup will be a bit faster. That presents some
* difficulties for Zap, which now has to have some knowledge of the nature
* of the hash function. Oh well. This should use the list traversal
* method of DRead...
+ *
+ * \param adc The dcache entry to be zapped.
*/
void
DZap(struct dcache *adc)
MReleaseReadLock(&afs_bufferLock);
}
+static void
+DFlushBuffer(struct buffer *ab) {
+ struct osi_file *tfile;
+
+#if defined(LINUX_USE_FH)
+ tfile = afs_CFileOpen(&ab->fh, ab->fh_type);
+#else
+ tfile = afs_CFileOpen(ab->inode);
+#endif
+ afs_CFileWrite(tfile, ab->page * AFS_BUFFER_PAGESIZE,
+ ab->data, AFS_BUFFER_PAGESIZE);
+ ab->dirty = 0; /* Clear the dirty flag */
+ afs_CFileClose(tfile);
+}
+
+void
+DFlushDCache(struct dcache *adc)
+{
+ int i;
+ struct buffer *tb;
+
+ 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) {
+ ObtainWriteLock(&tb->lock, 702);
+ tb->lockers++;
+ ReleaseReadLock(&afs_bufferLock);
+ if (tb->dirty) {
+ DFlushBuffer(tb);
+ }
+ tb->lockers--;
+ ReleaseWriteLock(&tb->lock);
+ ObtainReadLock(&afs_bufferLock);
+ }
+
+ ReleaseReadLock(&afs_bufferLock);
+}
+
void
DFlush(void)
{
/* Flush all the modified buffers. */
register int i;
register struct buffer *tb;
- struct osi_file *tfile;
AFS_STATCNT(DFlush);
tb = Buffers;
* we cannot lock afs_xdcache). In addition, we cannot obtain
* a dcache lock while holding the tb->lock of the same file
* since that can deadlock with DRead/DNew */
- tfile = afs_CFileOpen(tb->inode);
- afs_CFileWrite(tfile, tb->page * AFS_BUFFER_PAGESIZE,
- tb->data, AFS_BUFFER_PAGESIZE);
- tb->dirty = 0; /* Clear the dirty flag */
- afs_CFileClose(tfile);
+ DFlushBuffer(tb);
}
tb->lockers--;
MReleaseWriteLock(&tb->lock);