Skip to contentSkip to conversation

: v9fs: add readpage support

PATCH In review Eric Van Hensbergen 2 participants 6 messages Jan 11, 2006 – Jan 13, 2006

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 : v9fs: add readpage support

Subject: [PATCH] v9fs: add readpage support

v9fs mmap support was originally removed from v9fs at Al Viro's request, but recently there have been requests from folks who want readpage functionality (primarily to enable execution of files mounted via 9P). This patch adds readpage support (but not writepage which contained most of the objectionable code). It passes FSX (and other regressions) so it should be relatively safe.

---

 fs/9p/Makefile    |    1 
 fs/9p/v9fs_vfs.h  |    1 
 fs/9p/vfs_addr.c  |  109 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 fs/9p/vfs_file.c  |    3 +
 fs/9p/vfs_inode.c |    1 
 5 files changed, 115 insertions(+), 0 deletions(-)
 create mode 100644 fs/9p/vfs_addr.c

2d3190fce2418fc07d672ceb9d072b1cffb8be7f

fs/9p/Makefile +1 -0
index 3d02308..2f4ce43 100644
@@ -8,6 +8,7 @@ obj-$(CONFIG_9P_FS) := 9p2000.o
 	conv.o \
 	vfs_super.o \
 	vfs_inode.o \
+	vfs_addr.o \
 	vfs_file.o \
 	vfs_dir.o \
 	vfs_dentry.o \
fs/9p/v9fs_vfs.h +1 -0
index c78502a..69cf290 100644
@@ -39,6 +39,7 @@
  */
 
 extern struct file_system_type v9fs_fs_type;
+extern struct address_space_operations v9fs_addr_operations;
 extern struct file_operations v9fs_file_operations;
 extern struct file_operations v9fs_dir_operations;
 extern struct dentry_operations v9fs_dentry_operations;
fs/9p/vfs_addr.c new file +109 -0

109 lines not on this page · raw message

fs/9p/vfs_file.c +3 -0
index 6852f0e..feddc5c 100644
@@ -289,6 +289,8 @@ v9fs_file_write(struct file *filp, const
 		total += result;
 	} while (count);
 
+	invalidate_inode_pages2(inode->i_mapping);
+
 	return total;
 }
 
@@ -299,4 +301,5 @@ struct file_operations v9fs_file_operati
 	.open = v9fs_file_open,
 	.release = v9fs_dir_release,
 	.lock = v9fs_file_lock,
+	.mmap = generic_file_mmap,
 };
fs/9p/vfs_inode.c +1 -0
index a17b288..91f5524 100644
@@ -177,6 +177,7 @@ struct inode *v9fs_get_inode(struct supe
 		inode->i_blocks = 0;
 		inode->i_rdev = 0;
 		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+		inode->i_mapping->a_ops = &v9fs_addr_operations;
 
 		switch (mode & S_IFMT) {
 		case S_IFIFO:
Signature · 1 line
1.1.0
#1 lore raw
Quoted 39 lines · [email protected] (Eric Van Hensbergen) wrote:

Subject: [PATCH] v9fs: add readpage support

v9fs mmap support was originally removed from v9fs at Al Viro's request, but recently there have been requests from folks who want readpage functionality (primarily to enable execution of files mounted via 9P). This patch adds readpage support (but not writepage which contained most of the objectionable code). It passes FSX (and other regressions) so it should be relatively safe.

fs/9p/vfs_addr.c new file +29 -0
+
+static int v9fs_vfs_readpage(struct file *filp, struct page *page)
+{  
+	char *buffer = NULL;
+	int retval = -EIO;
+	loff_t offset = page_offset(page);
+	int count = PAGE_CACHE_SIZE;
+	struct inode *inode = filp->f_dentry->d_inode;
+	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
+	int rsize = v9ses->maxdata - V9FS_IOHDRSZ;
+	struct v9fs_fid *v9f = filp->private_data;
+	struct v9fs_fcall *fcall = NULL;
+	int fid = v9f->fid;
+	int total = 0;
+	int result = 0;
+
+	buffer = kmap(page);
+	do {
+		if (count < rsize)
+			rsize = count;
+
+		result = v9fs_t_read(v9ses, fid, offset, rsize, &fcall);
+
+		if (result < 0) {
+			printk(KERN_ERR "v9fs_t_read returned %d\n",
+			       result);
+
+			kfree(fcall);
+			goto UnmapAndUnlock;

fs/9p/vfs_addr.c line 90

Quoted 10 lines
fs/9p/vfs_addr.c new file +10 -0
+		} else
+			offset += result;
+
+		memcpy(buffer, fcall->params.rread.data, result);
+
+		count -= result;
+		buffer += result;
+		total += result;
+
+		kfree(fcall);

Minor thing: from my reading of v9fs_mux_rpc() there's potential for a double-kfree here. Either v9fs_mux_rpc() needs to be changed to unambiguously zero out *rcall (or, better, v9fs_t_read does it) or you need to zero fcall on each go around the loop.

fs/9p/vfs_addr.c line 98

Quoted 7 lines
fs/9p/vfs_addr.c new file +7 -0
+		if (result < rsize)
+			break;
+	} while (count);
+
+	memset(buffer, 0, count);
+	flush_dcache_page(page);
+	SetPageUptodate(page);

if (result < rsize), is the page really up to date?

fs/9p/vfs_addr.c line 102

Quoted 4 lines
fs/9p/vfs_addr.c new file +4 -0
+	retval = 0;
+
+      UnmapAndUnlock:
+	kunmap(page);

eww, do you really indent labels like that?

fs/9p/vfs_file.c v9fs_file_write(struct file *filp, const · line 295

Quoted 12 lines
fs/9p/vfs_file.c +2 -0
index 6852f0e..feddc5c 100644
@@ -289,6 +289,8 @@ v9fs_file_write(struct file *filp, const
 		total += result;
 	} while (count);
 
+	invalidate_inode_pages2(inode->i_mapping);
+
 	return total;
 }

That's a really scary function you have there. Can you explain the thinking behind its use here? What are we trying to achieve?

#2 lore raw
Quoted 47 lines · Andrew Morton
Quoted 46 lines · [email protected] (Eric Van Hensbergen) wrote:

Subject: [PATCH] v9fs: add readpage support

v9fs mmap support was originally removed from v9fs at Al Viro's request, but recently there have been requests from folks who want readpage functionality (primarily to enable execution of files mounted via 9P). This patch adds readpage support (but not writepage which contained most of the objectionable code). It passes FSX (and other regressions) so it should be relatively safe.

fs/9p/vfs_addr.c new file +36 -0
+
+static int v9fs_vfs_readpage(struct file *filp, struct page *page)
+{
+     char *buffer = NULL;
+     int retval = -EIO;
+     loff_t offset = page_offset(page);
+     int count = PAGE_CACHE_SIZE;
+     struct inode *inode = filp->f_dentry->d_inode;
+     struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
+     int rsize = v9ses->maxdata - V9FS_IOHDRSZ;
+     struct v9fs_fid *v9f = filp->private_data;
+     struct v9fs_fcall *fcall = NULL;
+     int fid = v9f->fid;
+     int total = 0;
+     int result = 0;
+
+     buffer = kmap(page);
+     do {
+             if (count < rsize)
+                     rsize = count;
+
+             result = v9fs_t_read(v9ses, fid, offset, rsize, &fcall);
+
+             if (result < 0) {
+                     printk(KERN_ERR "v9fs_t_read returned %d\n",
+                            result);
+
+                     kfree(fcall);
+                     goto UnmapAndUnlock;
+             } else
+                     offset += result;
+
+             memcpy(buffer, fcall->params.rread.data, result);
+
+             count -= result;
+             buffer += result;
Quoted 10 lines

fs/9p/vfs_addr.c line 90

Quoted 3 lines
fs/9p/vfs_addr.c new file +3 -0
+             total += result;
+
+             kfree(fcall);

Minor thing: from my reading of v9fs_mux_rpc() there's potential for a double-kfree here. Either v9fs_mux_rpc() needs to be changed to unambiguously zero out *rcall (or, better, v9fs_t_read does it) or you need to zero fcall on each go around the loop.

Okay I'll take a look at this in the context of both the old mux and the new mux code.

Quoted 10 lines

fs/9p/vfs_addr.c line 98

Quoted 7 lines
fs/9p/vfs_addr.c new file +7 -0
+             if (result < rsize)
+                     break;
+     } while (count);
+
+     memset(buffer, 0, count);
+     flush_dcache_page(page);
+     SetPageUptodate(page);

if (result < rsize), is the page really up to date?

maybe? Its been a while since I looked at this code, but I believe the logic is that if you are approaching the end of the file you'll get less than rsize bytes back and then you just fill in the rest of the page with zeros.

Quoted 7 lines

fs/9p/vfs_addr.c line 102

Quoted 4 lines
fs/9p/vfs_addr.c new file +4 -0
+     retval = 0;
+
+      UnmapAndUnlock:
+     kunmap(page);

eww, do you really indent labels like that?

No, something funky happened and I didn't proof the patch like I should have.

Quoted 8 lines
Quoted 8 lines
fs/9p/vfs_file.c +0 -0
index 6852f0e..feddc5c 100644
@@ -289,6 +289,8 @@ v9fs_file_write(struct file *filp, const
              total += result;
      } while (count);
 
Quoted 8 lines

fs/9p/vfs_file.c v9fs_file_write(struct file *filp, const · line 295

Quoted 4 lines
fs/9p/vfs_file.c +2 -0
+     invalidate_inode_pages2(inode->i_mapping);
+
      return total;
 }

That's a really scary function you have there. Can you explain the thinking behind its use here? What are we trying to achieve?

Its quite possible I've done the wrong thing here. The intent is to make sure that any stuff that might be in the page cache due to an mmap is flushed when I do a write. This approach is overkill, I should probably just flush anything in the cache that the write affects.

I'll take another look at the mux stuff and also see if I can come up with a less brute-force approach to invalidating the page cache.

thanks for the comments.

-eric

#3 lore raw
In reply to Andrew Morton
Quoted 17 lines · Andrew Morton
Quoted 16 lines · [email protected] (Eric Van Hensbergen) wrote:
fs/9p/vfs_addr.c new file +16 -0
+
+             result = v9fs_t_read(v9ses, fid, offset, rsize, &fcall);
+
+             if (result < 0) {
+                     printk(KERN_ERR "v9fs_t_read returned %d\n",
+                            result);
+
+                     kfree(fcall);
+                     goto UnmapAndUnlock;
+             } else
+                     offset += result;
+
+             memcpy(buffer, fcall->params.rread.data, result);
+
+             count -= result;
+             buffer += result;
Quoted 10 lines

fs/9p/vfs_addr.c line 90

Quoted 3 lines
fs/9p/vfs_addr.c new file +3 -0
+             total += result;
+
+             kfree(fcall);

Minor thing: from my reading of v9fs_mux_rpc() there's potential for a double-kfree here. Either v9fs_mux_rpc() needs to be changed to unambiguously zero out *rcall (or, better, v9fs_t_read does it) or you need to zero fcall on each go around the loop.

Okay, I had a chance to go back and look into this deeper when applied on top of Lucho's new mux code. It appears (to Lucho and I) that the the v9fs_mux_rpc() code zero's out *rcall really early on, so I don't see where this could lead to a double kfree. If you still think we are missing something, let me know and I'll have another look.

Quoted 8 lines
Quoted 8 lines
fs/9p/vfs_file.c +0 -0
index 6852f0e..feddc5c 100644
@@ -289,6 +289,8 @@ v9fs_file_write(struct file *filp, const
              total += result;
      } while (count);
 
Quoted 5 lines

fs/9p/vfs_file.c v9fs_file_write(struct file *filp, const · line 295

Quoted 4 lines
fs/9p/vfs_file.c +2 -0
+     invalidate_inode_pages2(inode->i_mapping);
+
      return total;
 }

I went looking for an example of how to do this better. More or less, v9fs reads and writes are similar to DirectIO since they don't go through the page-cache. So, I looked at what NFS does when it gets a DirectIO write, and it looks (to me) like it does more or less the same thing:
(from nfs_file_direct_write() in fs/nfs/direct.c)

        retval = nfs_direct_write(inode, ctx, &iov, pos, 1);
        if (mapping->nrpages)
                invalidate_inode_pages2(mapping);

Now, that being said, it still seems to me to be a bit heavy weight -- do folks have a better pointer to code that I can use as an example of how to do this more efficiently?

-eric

#4 lore raw
Quoted 11 lines · Eric Van Hensbergen
Quoted 10 lines

fs/9p/vfs_file.c v9fs_file_write(struct file *filp, const · line 295

Quoted 9 lines
fs/9p/vfs_file.c +2 -0
@@ -289,6 +289,8 @@ v9fs_file_write(struct file *filp, const
              total += result;
      } while (count);
 
+     invalidate_inode_pages2(inode->i_mapping);
+
      return total;
 }
Quoted 3 lines

I went looking for an example of how to do this better. More or less, v9fs reads and writes are similar to DirectIO since they don't go through the page-cache.

hm. Why not?

Quoted 11 lines

So, I looked at what NFS does when it gets a
DirectIO write, and it looks (to me) like it does more or less the same thing:
(from nfs_file_direct_write() in fs/nfs/direct.c)

        retval = nfs_direct_write(inode, ctx, &iov, pos, 1);
        if (mapping->nrpages)
                invalidate_inode_pages2(mapping);

Now, that being said, it still seems to me to be a bit heavy weight -- do folks have a better pointer to code that I can use as an example of how to do this more efficiently?

Not really. If that's what you need to do then that's the way to do it. We've had nasty races and other problems wrt invalidate_inode_pages2 and pagefaults, so I suggest you test that mix carefully.

Have you tried fsx-linux? It's really good for finding data integrity bugs. There's a copy in
http://www.zip.com.au/~akpm/linux/patches/stuff/ext3-tools.tar.gz.

I'd suggest that you want the mapping->nrpages test - it'll be a useful speedup in the common case.

Of course, someone could come in and add a page to pagecache via a pagefault at any time after that test, but that's true of invalidate_inode_pages2() in general.

#5 lore raw
Quoted 8 lines · Andrew Morton
Quoted 4 lines · Eric Van Hensbergen

I went looking for an example of how to do this better. More or less, v9fs reads and writes are similar to DirectIO since they don't go through the page-cache.

hm. Why not?

At the moment we'd rather not cache anything with v9fs as it hides operations from the servers, and in the case of synthetic servers it can be a bad thing. There is a somewhat well-understood strategy for how to do cacheing of static files in a sane manner under 9P, but we were holding off on trying to move that into v9fs for the time being. The only reason we added the read-only mmap support back in was to support users who were trying to access executables over 9P connections.

Quoted 5 lines
Quoted 4 lines

Now, that being said, it still seems to me to be a bit heavy weight -- do folks have a better pointer to code that I can use as an example of how to do this more efficiently?

Quoted 8 lines

Not really. If that's what you need to do then that's the way to do it. We've had nasty races and other problems wrt invalidate_inode_pages2 and pagefaults, so I suggest you test that mix carefully.

Have you tried fsx-linux? It's really good for finding data integrity bugs. There's a copy in
http://www.zip.com.au/~akpm/linux/patches/stuff/ext3-tools.tar.gz.

We've been regression testing with vanilla fsx, I'll upgrade to fsx-linux and make sure we are clean.

Quoted 4 lines

I'd suggest that you want the mapping->nrpages test - it'll be a useful speedup in the common case.

Yeah, as I was tracing through the invalidate_inode_pages2() this morning I realized this is probably a good idea. Should have a new patch to you by the end of the weekend.

-eric