Commit 91f79c43 authored by Al Viro's avatar Al Viro

new helper: iov_iter_get_pages_alloc()

same as iov_iter_get_pages(), except that pages array is allocated
(kmalloc if possible, vmalloc if that fails) and left for caller to
free.  Lustre and NFS ->direct_IO() switched to it.
Signed-off-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
parent f67da30c
...@@ -218,14 +218,11 @@ static void ll_free_user_pages(struct page **pages, int npages, int do_dirty) ...@@ -218,14 +218,11 @@ static void ll_free_user_pages(struct page **pages, int npages, int do_dirty)
int i; int i;
for (i = 0; i < npages; i++) { for (i = 0; i < npages; i++) {
if (pages[i] == NULL)
break;
if (do_dirty) if (do_dirty)
set_page_dirty_lock(pages[i]); set_page_dirty_lock(pages[i]);
page_cache_release(pages[i]); page_cache_release(pages[i]);
} }
kvfree(pages);
OBD_FREE_LARGE(pages, npages * sizeof(*pages));
} }
ssize_t ll_direct_rw_pages(const struct lu_env *env, struct cl_io *io, ssize_t ll_direct_rw_pages(const struct lu_env *env, struct cl_io *io,
...@@ -370,10 +367,9 @@ static ssize_t ll_direct_IO_26(int rw, struct kiocb *iocb, ...@@ -370,10 +367,9 @@ static ssize_t ll_direct_IO_26(int rw, struct kiocb *iocb,
struct file *file = iocb->ki_filp; struct file *file = iocb->ki_filp;
struct inode *inode = file->f_mapping->host; struct inode *inode = file->f_mapping->host;
struct ccc_object *obj = cl_inode2ccc(inode); struct ccc_object *obj = cl_inode2ccc(inode);
long count = iov_iter_count(iter); ssize_t count = iov_iter_count(iter);
long tot_bytes = 0, result = 0; ssize_t tot_bytes = 0, result = 0;
struct ll_inode_info *lli = ll_i2info(inode); struct ll_inode_info *lli = ll_i2info(inode);
unsigned long seg = 0;
long size = MAX_DIO_SIZE; long size = MAX_DIO_SIZE;
int refcheck; int refcheck;
...@@ -407,63 +403,49 @@ static ssize_t ll_direct_IO_26(int rw, struct kiocb *iocb, ...@@ -407,63 +403,49 @@ static ssize_t ll_direct_IO_26(int rw, struct kiocb *iocb,
mutex_lock(&inode->i_mutex); mutex_lock(&inode->i_mutex);
LASSERT(obj->cob_transient_pages == 0); LASSERT(obj->cob_transient_pages == 0);
for (seg = 0; seg < iter->nr_segs; seg++) { while (iov_iter_count(iter)) {
long iov_left = iter->iov[seg].iov_len; struct page **pages;
unsigned long user_addr = (unsigned long)iter->iov[seg].iov_base; size_t offs;
count = min_t(size_t, iov_iter_count(iter), size);
if (rw == READ) { if (rw == READ) {
if (file_offset >= i_size_read(inode)) if (file_offset >= i_size_read(inode))
break; break;
if (file_offset + iov_left > i_size_read(inode)) if (file_offset + count > i_size_read(inode))
iov_left = i_size_read(inode) - file_offset; count = i_size_read(inode) - file_offset;
} }
while (iov_left > 0) { result = iov_iter_get_pages_alloc(iter, &pages, count, &offs);
struct page **pages; if (likely(result > 0)) {
int page_count, max_pages = 0; int n = (result + offs + PAGE_SIZE - 1) / PAGE_SIZE;
long bytes; result = ll_direct_IO_26_seg(env, io, rw, inode,
file->f_mapping,
bytes = min(size, iov_left); result, file_offset,
page_count = ll_get_user_pages(rw, user_addr, bytes, pages, n);
&pages, &max_pages); ll_free_user_pages(pages, n, rw==READ);
if (likely(page_count > 0)) { }
if (unlikely(page_count < max_pages)) if (unlikely(result <= 0)) {
bytes = page_count << PAGE_CACHE_SHIFT; /* If we can't allocate a large enough buffer
result = ll_direct_IO_26_seg(env, io, rw, inode, * for the request, shrink it to a smaller
file->f_mapping, * PAGE_SIZE multiple and try again.
bytes, file_offset, * We should always be able to kmalloc for a
pages, page_count); * page worth of page pointers = 4MB on i386. */
ll_free_user_pages(pages, max_pages, rw==READ); if (result == -ENOMEM &&
} else if (page_count == 0) { size > (PAGE_CACHE_SIZE / sizeof(*pages)) *
GOTO(out, result = -EFAULT); PAGE_CACHE_SIZE) {
} else { size = ((((size / 2) - 1) |
result = page_count; ~CFS_PAGE_MASK) + 1) &
} CFS_PAGE_MASK;
if (unlikely(result <= 0)) { CDEBUG(D_VFSTRACE,"DIO size now %lu\n",
/* If we can't allocate a large enough buffer size);
* for the request, shrink it to a smaller continue;
* PAGE_SIZE multiple and try again.
* We should always be able to kmalloc for a
* page worth of page pointers = 4MB on i386. */
if (result == -ENOMEM &&
size > (PAGE_CACHE_SIZE / sizeof(*pages)) *
PAGE_CACHE_SIZE) {
size = ((((size / 2) - 1) |
~CFS_PAGE_MASK) + 1) &
CFS_PAGE_MASK;
CDEBUG(D_VFSTRACE,"DIO size now %lu\n",
size);
continue;
}
GOTO(out, result);
} }
tot_bytes += result; GOTO(out, result);
file_offset += result;
iov_left -= result;
user_addr += result;
} }
iov_iter_advance(iter, result);
tot_bytes += result;
file_offset += result;
} }
out: out:
LASSERT(obj->cob_transient_pages == 0); LASSERT(obj->cob_transient_pages == 0);
......
This diff is collapsed.
...@@ -73,6 +73,8 @@ void iov_iter_init(struct iov_iter *i, int direction, const struct iovec *iov, ...@@ -73,6 +73,8 @@ void iov_iter_init(struct iov_iter *i, int direction, const struct iovec *iov,
unsigned long nr_segs, size_t count); unsigned long nr_segs, size_t count);
ssize_t iov_iter_get_pages(struct iov_iter *i, struct page **pages, ssize_t iov_iter_get_pages(struct iov_iter *i, struct page **pages,
size_t maxsize, size_t *start); size_t maxsize, size_t *start);
ssize_t iov_iter_get_pages_alloc(struct iov_iter *i, struct page ***pages,
size_t maxsize, size_t *start);
int iov_iter_npages(const struct iov_iter *i, int maxpages); int iov_iter_npages(const struct iov_iter *i, int maxpages);
static inline size_t iov_iter_count(struct iov_iter *i) static inline size_t iov_iter_count(struct iov_iter *i)
......
#include <linux/export.h> #include <linux/export.h>
#include <linux/uio.h> #include <linux/uio.h>
#include <linux/pagemap.h> #include <linux/pagemap.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
size_t copy_page_to_iter(struct page *page, size_t offset, size_t bytes, size_t copy_page_to_iter(struct page *page, size_t offset, size_t bytes,
struct iov_iter *i) struct iov_iter *i)
...@@ -263,6 +265,44 @@ ssize_t iov_iter_get_pages(struct iov_iter *i, ...@@ -263,6 +265,44 @@ ssize_t iov_iter_get_pages(struct iov_iter *i,
} }
EXPORT_SYMBOL(iov_iter_get_pages); EXPORT_SYMBOL(iov_iter_get_pages);
ssize_t iov_iter_get_pages_alloc(struct iov_iter *i,
struct page ***pages, size_t maxsize,
size_t *start)
{
size_t offset = i->iov_offset;
const struct iovec *iov = i->iov;
size_t len;
unsigned long addr;
void *p;
int n;
int res;
len = iov->iov_len - offset;
if (len > i->count)
len = i->count;
if (len > maxsize)
len = maxsize;
addr = (unsigned long)iov->iov_base + offset;
len += *start = addr & (PAGE_SIZE - 1);
addr &= ~(PAGE_SIZE - 1);
n = (len + PAGE_SIZE - 1) / PAGE_SIZE;
p = kmalloc(n * sizeof(struct page *), GFP_KERNEL);
if (!p)
p = vmalloc(n * sizeof(struct page *));
if (!p)
return -ENOMEM;
res = get_user_pages_fast(addr, n, (i->type & WRITE) != WRITE, p);
if (unlikely(res < 0)) {
kvfree(p);
return res;
}
*pages = p;
return (res == n ? len : res * PAGE_SIZE) - *start;
}
EXPORT_SYMBOL(iov_iter_get_pages_alloc);
int iov_iter_npages(const struct iov_iter *i, int maxpages) int iov_iter_npages(const struct iov_iter *i, int maxpages)
{ {
size_t offset = i->iov_offset; size_t offset = i->iov_offset;
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment