[PATCH v1] fuse: add configurable max_pages parameter

From: Constantine Shulyupin
Date: Sun Aug 06 2017 - 13:26:11 EST

Next message: Matthew Garrett: "Re: [PATCH] Allow automatic kernel taint on unsigned module load to be disabled"
Previous message: Mikko Rapeli: "[PATCH v06 26/36] uapi xen/privcmd.h: fix compilation in userspace"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

Replace define FUSE_MAX_PAGES_PER_REQ with the configurable
mount parameter max_pages to improve performance.
To utilize the max_pages parameter you must also increase the
value of bufsize in the user mode library.

Signed-off-by: Constantine Shulyupin <const@xxxxxxxxxxxxx>
---
Documentation/filesystems/fuse.txt | 5 +++-
fs/fuse/dev.c | 2 +-
fs/fuse/file.c | 54 +++++++++++++++++++++-----------------
fs/fuse/fuse_i.h | 5 +++-
fs/fuse/inode.c | 12 +++++++++
5 files changed, 51 insertions(+), 27 deletions(-)

diff --git a/Documentation/filesystems/fuse.txt b/Documentation/filesystems/fuse.txt
index 13af4a4..d4e832f 100644
--- a/Documentation/filesystems/fuse.txt
+++ b/Documentation/filesystems/fuse.txt
@@ -108,7 +108,10 @@ Mount options

With this option the maximum size of read operations can be set.
The default is infinite. Note that the size of read requests is
- limited anyway to 32 pages (which is 128kbyte on i386).
+ limited anyway to max_pages (which by default is 32 or 128KB on x86).
+
+'max_pages=N'
+ Maximal number of pages per request. The default is 32 or 128KB on x86.

'blksize=N'

diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index ebb5e37..f750f30 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -1707,7 +1707,7 @@ static int fuse_retrieve(struct fuse_conn *fc, struct inode *inode,
num = file_size - outarg->offset;

num_pages = (num + offset + PAGE_SIZE - 1) >> PAGE_SHIFT;
- num_pages = min(num_pages, FUSE_MAX_PAGES_PER_REQ);
+ num_pages = min(num_pages, fc->max_pages);

req = fuse_get_req(fc, num_pages);
if (IS_ERR(req))
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 6c0aed7..de00cf3 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -861,11 +861,11 @@ static int fuse_readpages_fill(void *_data, struct page *page)
fuse_wait_on_page_writeback(inode, page->index);

if (req->num_pages &&
- (req->num_pages == FUSE_MAX_PAGES_PER_REQ ||
+ (req->num_pages == fc->max_pages ||
(req->num_pages + 1) * PAGE_CACHE_SIZE > fc->max_read ||
req->pages[req->num_pages - 1]->index + 1 != page->index)) {
int nr_alloc = min_t(unsigned, data->nr_pages,
- FUSE_MAX_PAGES_PER_REQ);
+ fc->max_pages);
fuse_send_readpages(req, data->file);
if (fc->async_read)
req = fuse_get_req_for_background(fc, nr_alloc);
@@ -901,7 +901,7 @@ static int fuse_readpages(struct file *file, struct address_space *mapping,
struct fuse_conn *fc = get_fuse_conn(inode);
struct fuse_fill_data data;
int err;
- int nr_alloc = min_t(unsigned, nr_pages, FUSE_MAX_PAGES_PER_REQ);
+ int nr_alloc = min_t(unsigned, nr_pages, fc->max_pages);

err = -EIO;
if (is_bad_inode(inode))
@@ -1111,12 +1111,12 @@ static ssize_t fuse_fill_write_pages(struct fuse_req *req,
return count > 0 ? count : err;
}

-static inline unsigned fuse_wr_pages(loff_t pos, size_t len)
+static inline unsigned fuse_wr_pages(loff_t pos, size_t len, unsigned max_pages)
{
return min_t(unsigned,
((pos + len - 1) >> PAGE_CACHE_SHIFT) -
(pos >> PAGE_CACHE_SHIFT) + 1,
- FUSE_MAX_PAGES_PER_REQ);
+ max_pages);
}

static ssize_t fuse_perform_write(struct file *file,
@@ -1138,7 +1138,8 @@ static ssize_t fuse_perform_write(struct file *file,
do {
struct fuse_req *req;
ssize_t count;
- unsigned nr_pages = fuse_wr_pages(pos, iov_iter_count(ii));
+ unsigned nr_pages = fuse_wr_pages(pos, iov_iter_count(ii),
+ fc->max_pages);

req = fuse_get_req(fc, nr_pages);
if (IS_ERR(req)) {
@@ -1326,9 +1327,10 @@ static int fuse_get_user_pages(struct fuse_req *req, struct iov_iter *ii,
return 0;
}

-static inline int fuse_iter_npages(const struct iov_iter *ii_p)
+static inline int fuse_iter_npages(struct fuse_conn *fc,
+ const struct iov_iter *ii_p)
{
- return iov_iter_npages(ii_p, FUSE_MAX_PAGES_PER_REQ);
+ return iov_iter_npages(ii_p, fc->max_pages);
}

ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter,
@@ -1350,9 +1352,10 @@ ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter,
struct fuse_req *req;

if (io->async)
- req = fuse_get_req_for_background(fc, fuse_iter_npages(iter));
+ req = fuse_get_req_for_background(fc,
+ fuse_iter_npages(fc, iter));
else
- req = fuse_get_req(fc, fuse_iter_npages(iter));
+ req = fuse_get_req(fc, fuse_iter_npages(fc, iter));
if (IS_ERR(req))
return PTR_ERR(req);

@@ -1398,9 +1401,10 @@ ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter,
fuse_put_request(fc, req);
if (io->async)
req = fuse_get_req_for_background(fc,
- fuse_iter_npages(iter));
+ fuse_iter_npages(fc, iter));
else
- req = fuse_get_req(fc, fuse_iter_npages(iter));
+ req = fuse_get_req(fc,
+ fuse_iter_npages(fc, iter));
if (IS_ERR(req))
break;
}
@@ -1828,7 +1832,7 @@ static int fuse_writepages_fill(struct page *page,
is_writeback = fuse_page_is_writeback(inode, page->index);

if (req && req->num_pages &&
- (is_writeback || req->num_pages == FUSE_MAX_PAGES_PER_REQ ||
+ (is_writeback || req->num_pages == fc->max_pages ||
(req->num_pages + 1) * PAGE_CACHE_SIZE > fc->max_write ||
data->orig_pages[req->num_pages - 1]->index + 1 != page->index)) {
fuse_writepages_send(data);
@@ -1856,7 +1860,7 @@ static int fuse_writepages_fill(struct page *page,
struct fuse_inode *fi = get_fuse_inode(inode);

err = -ENOMEM;
- req = fuse_request_alloc_nofs(FUSE_MAX_PAGES_PER_REQ);
+ req = fuse_request_alloc_nofs(fc->max_pages);
if (!req) {
__free_page(tmp_page);
goto out_unlock;
@@ -1913,6 +1917,7 @@ static int fuse_writepages(struct address_space *mapping,
struct writeback_control *wbc)
{
struct inode *inode = mapping->host;
+ struct fuse_conn *fc = get_fuse_conn(inode);
struct fuse_fill_wb_data data;
int err;

@@ -1925,7 +1930,7 @@ static int fuse_writepages(struct address_space *mapping,
data.ff = NULL;

err = -ENOMEM;
- data.orig_pages = kcalloc(FUSE_MAX_PAGES_PER_REQ,
+ data.orig_pages = kcalloc(fc->max_pages,
sizeof(struct page *),
GFP_NOFS);
if (!data.orig_pages)
@@ -2367,10 +2372,11 @@ static int fuse_copy_ioctl_iovec_old(struct iovec *dst, void *src,
}

/* Make sure iov_length() won't overflow */
-static int fuse_verify_ioctl_iov(struct iovec *iov, size_t count)
+static int fuse_verify_ioctl_iov(struct fuse_conn *fc, struct iovec *iov,
+ size_t count)
{
size_t n;
- u32 max = FUSE_MAX_PAGES_PER_REQ << PAGE_SHIFT;
+ u32 max = fc->max_pages << PAGE_SHIFT;

for (n = 0; n < count; n++, iov++) {
if (iov->iov_len > (size_t) max)
@@ -2493,7 +2499,7 @@ long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
BUILD_BUG_ON(sizeof(struct fuse_ioctl_iovec) * FUSE_IOCTL_MAX_IOV > PAGE_SIZE);

err = -ENOMEM;
- pages = kcalloc(FUSE_MAX_PAGES_PER_REQ, sizeof(pages[0]), GFP_KERNEL);
+ pages = kcalloc(fc->max_pages, sizeof(pages[0]), GFP_KERNEL);
iov_page = (struct iovec *) __get_free_page(GFP_KERNEL);
if (!pages || !iov_page)
goto out;
@@ -2532,7 +2538,7 @@ long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,

/* make sure there are enough buffer pages and init request with them */
err = -ENOMEM;
- if (max_pages > FUSE_MAX_PAGES_PER_REQ)
+ if (max_pages > fc->max_pages)
goto out;
while (num_pages < max_pages) {
pages[num_pages] = alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
@@ -2616,11 +2622,11 @@ long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
in_iov = iov_page;
out_iov = in_iov + in_iovs;

- err = fuse_verify_ioctl_iov(in_iov, in_iovs);
+ err = fuse_verify_ioctl_iov(fc, in_iov, in_iovs);
if (err)
goto out;

- err = fuse_verify_ioctl_iov(out_iov, out_iovs);
+ err = fuse_verify_ioctl_iov(fc, out_iov, out_iovs);
if (err)
goto out;

@@ -2804,9 +2810,9 @@ static void fuse_do_truncate(struct file *file)
fuse_do_setattr(inode, &attr, file);
}

-static inline loff_t fuse_round_up(loff_t off)
+static inline loff_t fuse_round_up(struct fuse_conn *fc, loff_t off)
{
- return round_up(off, FUSE_MAX_PAGES_PER_REQ << PAGE_SHIFT);
+ return round_up(off, fc->max_pages << PAGE_SHIFT);
}

static ssize_t
@@ -2835,7 +2841,7 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter, loff_t offset)
if (async_dio && iov_iter_rw(iter) != WRITE && offset + count > i_size) {
if (offset >= i_size)
return 0;
- iov_iter_truncate(iter, fuse_round_up(i_size - offset));
+ iov_iter_truncate(iter, fuse_round_up(ff->fc, i_size - offset));
count = iov_iter_count(iter);
}

diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
index 5c4adc4..e3f9599 100644
--- a/fs/fuse/fuse_i.h
+++ b/fs/fuse/fuse_i.h
@@ -25,7 +25,7 @@
#include <linux/kref.h>

/** Max number of pages that can be used in a single read request */
-#define FUSE_MAX_PAGES_PER_REQ 32
+#define FUSE_DEFAULT_MAX_PAGES_PER_REQ 32

/** Bias for fi->writectr, meaning new writepages must not be sent */
#define FUSE_NOWRITE INT_MIN
@@ -478,6 +478,9 @@ struct fuse_conn {
/** Maximum write size */
unsigned max_write;

+ /** Maxmum number of pages that can be used in a single request */
+ unsigned max_pages;
+
/** Input queue */
struct fuse_iqueue iq;

diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 9904a1b..0798063 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -68,6 +68,7 @@ struct fuse_mount_data {
unsigned group_id_present:1;
unsigned flags;
unsigned max_read;
+ unsigned max_pages;
unsigned blksize;
};

@@ -444,6 +445,7 @@ enum {
OPT_ALLOW_OTHER,
OPT_USE_RDEV,
OPT_MAX_READ,
+ OPT_MAX_PAGES,
OPT_BLKSIZE,
OPT_ERR
};
@@ -457,6 +459,7 @@ static const match_table_t tokens = {
{OPT_ALLOW_OTHER, "allow_other"},
{OPT_USE_RDEV, "use_rdev"},
{OPT_MAX_READ, "max_read=%u"},
+ {OPT_MAX_PAGES, "max_pages=%u"},
{OPT_BLKSIZE, "blksize=%u"},
{OPT_ERR, NULL}
};
@@ -541,6 +544,12 @@ static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)
d->max_read = value;
break;

+ case OPT_MAX_PAGES:
+ if (match_int(&args[0], &value))
+ return 0;
+ d->max_pages = value;
+ break;
+
case OPT_BLKSIZE:
if (!is_bdev || match_int(&args[0], &value))
return 0;
@@ -574,6 +583,8 @@ static int fuse_show_options(struct seq_file *m, struct dentry *root)
seq_puts(m, ",use_rdev");
if (fc->max_read != ~0)
seq_printf(m, ",max_read=%u", fc->max_read);
+ if (fc->max_pages != FUSE_DEFAULT_MAX_PAGES_PER_REQ)
+ seq_printf(m, ",max_pages=%u", fc->max_pages);
if (sb->s_bdev && sb->s_blocksize != FUSE_DEFAULT_BLKSIZE)
seq_printf(m, ",blksize=%lu", sb->s_blocksize);
return 0;
@@ -1112,6 +1123,7 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
fc->user_id = d.user_id;
fc->group_id = d.group_id;
fc->max_read = max_t(unsigned, 4096, d.max_read);
+ fc->max_pages = d.max_pages ?: FUSE_DEFAULT_MAX_PAGES_PER_REQ;

/* Used by get_root_inode() */
sb->s_fs_info = fc;
--
2.7.4

Next message: Matthew Garrett: "Re: [PATCH] Allow automatic kernel taint on unsigned module load to be disabled"
Previous message: Mikko Rapeli: "[PATCH v06 26/36] uapi xen/privcmd.h: fix compilation in userspace"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]