#include <linux/pagemap.h>
#include <linux/writeback.h>
#include <linux/pagevec.h>
+#include <linux/aio.h>
#include "afs/lock.h"
#include "afs/afs_bypasscache.h"
#define MAX_ERRNO 1000L
#endif
+int cachefs_noreadpage = 0;
+
extern struct backing_dev_info *afs_backing_dev_info;
extern struct vcache *afs_globalVp;
* handling and use of bulkstats will need to be reflected here as well.
*/
static int
+#if defined(STRUCT_FILE_OPERATIONS_HAS_ITERATE)
+afs_linux_readdir(struct file *fp, struct dir_context *ctx)
+#else
afs_linux_readdir(struct file *fp, void *dirbuf, filldir_t filldir)
+#endif
{
struct vcache *avc = VTOAFS(FILE_INODE(fp));
struct vrequest treq;
* takes an offset in units of blobs, rather than bytes.
*/
code = 0;
+#if defined(STRUCT_FILE_OPERATIONS_HAS_ITERATE)
+ offset = ctx->pos;
+#else
offset = (int) fp->f_pos;
+#endif
while (1) {
dirpos = BlobScan(tdc, offset);
if (!dirpos)
* holding the GLOCK.
*/
AFS_GUNLOCK();
+#if defined(STRUCT_FILE_OPERATIONS_HAS_ITERATE)
+ /* dir_emit returns a bool - true when it succeeds.
+ * Inverse the result to fit with how we check "code" */
+ code = !dir_emit(ctx, de->name, len, ino, type);
+#else
code = (*filldir) (dirbuf, de->name, len, offset, ino, type);
+#endif
AFS_GLOCK();
}
DRelease(&entry, 0);
/* If filldir didn't fill in the last one this is still pointing to that
* last attempt.
*/
+#if defined(STRUCT_FILE_OPERATIONS_HAS_ITERATE)
+ ctx->pos = (loff_t) offset;
+#else
fp->f_pos = (loff_t) offset;
+#endif
ReleaseReadLock(&tdc->lock);
afs_PutDCache(tdc);
struct file_operations afs_dir_fops = {
.read = generic_read_dir,
+#if defined(STRUCT_FILE_OPERATIONS_HAS_ITERATE)
+ .iterate = afs_linux_readdir,
+#else
.readdir = afs_linux_readdir,
+#endif
#ifdef HAVE_UNLOCKED_IOCTL
.unlocked_ioctl = afs_unlocked_xioctl,
#else
if (cacheDiskType != AFS_FCACHE_TYPE_UFS)
return 0;
+ /* No readpage (ex: tmpfs) , skip */
+ if (cachefs_noreadpage)
+ return 0;
+
/* Can't do anything if the vcache isn't statd , or if the read
* crosses a chunk boundary.
*/
/* Is the dcache we've been given currently up to date */
if (!hsame(avc->f.m.DataVersion, tdc->f.versionNo) ||
- (tdc->dflags & DFFetching)) {
- ReleaseWriteLock(&avc->lock);
- ReleaseReadLock(&tdc->lock);
- afs_PutDCache(tdc);
- return 0;
- }
+ (tdc->dflags & DFFetching))
+ goto out;
/* Update our hint for future abuse */
avc->dchint = tdc;
/* XXX - I suspect we should be locking the inodes before we use them! */
AFS_GUNLOCK();
cacheFp = afs_linux_raw_open(&tdc->f.inode);
+ if (!cacheFp->f_dentry->d_inode->i_mapping->a_ops->readpage) {
+ cachefs_noreadpage = 1;
+ AFS_GLOCK();
+ goto out;
+ }
pagevec_init(&lrupv, 0);
code = afs_linux_read_cache(cacheFp, pp, tdc->f.chunk, &lrupv, NULL);
*codep = code;
return 1;
+
+out:
+ ReleaseWriteLock(&avc->lock);
+ ReleaseReadLock(&tdc->lock);
+ afs_PutDCache(tdc);
+ return 0;
}
/* afs_linux_readpage
if (cacheDiskType == AFS_FCACHE_TYPE_MEM)
return 0;
+ /* No readpage (ex: tmpfs) , skip */
+ if (cachefs_noreadpage)
+ return 0;
+
AFS_GLOCK();
if ((code = afs_linux_VerifyVCache(avc, NULL))) {
AFS_GUNLOCK();
ObtainReadLock(&tdc->lock);
if (!hsame(avc->f.m.DataVersion, tdc->f.versionNo) ||
(tdc->dflags & DFFetching)) {
+ goto out;
ReleaseReadLock(&tdc->lock);
afs_PutDCache(tdc);
tdc = NULL;
}
}
AFS_GUNLOCK();
- if (tdc)
+ if (tdc) {
cacheFp = afs_linux_raw_open(&tdc->f.inode);
+ if (!cacheFp->f_dentry->d_inode->i_mapping->a_ops->readpage) {
+ cachefs_noreadpage = 1;
+ goto out;
+ }
+ }
}
if (tdc && !add_to_page_cache(page, mapping, page->index,
if (pagevec_count(&lrupv))
__pagevec_lru_add_file(&lrupv);
+out:
if (tdc)
filp_close(cacheFp, NULL);