* GPL HEADER END
*/
/*
- * Copyright 2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
+ *
+ * Copyright (c) 2011 Whamcloud, Inc.
+ *
*/
/*
* This file is part of Lustre, http://www.lustre.org/
*max_pages = (user_addr + size + CFS_PAGE_SIZE - 1) >> CFS_PAGE_SHIFT;
*max_pages -= user_addr >> CFS_PAGE_SHIFT;
- OBD_ALLOC_WAIT(*pages, *max_pages * sizeof(**pages));
+ OBD_ALLOC_LARGE(*pages, *max_pages * sizeof(**pages));
if (*pages) {
down_read(¤t->mm->mmap_sem);
result = get_user_pages(current, current->mm, user_addr,
NULL);
up_read(¤t->mm->mmap_sem);
if (unlikely(result <= 0))
- OBD_FREE(*pages, *max_pages * sizeof(**pages));
+ OBD_FREE_LARGE(*pages, *max_pages * sizeof(**pages));
}
return result;
page_cache_release(pages[i]);
}
- OBD_FREE(pages, npages * sizeof(*pages));
+ OBD_FREE_LARGE(pages, npages * sizeof(*pages));
}
ssize_t ll_direct_rw_pages(const struct lu_env *env, struct cl_io *io,
int i;
ssize_t rc = 0;
loff_t file_offset = pv->ldp_start_offset;
- size_t size = pv->ldp_size;
+ long size = pv->ldp_size;
int page_count = pv->ldp_nr;
struct page **pages = pv->ldp_pages;
- size_t page_size = cl_page_size(obj);
+ long page_size = cl_page_size(obj);
+ bool do_io;
+ int io_pages = 0;
ENTRY;
queue = &io->ci_queue;
for (i = 0; i < page_count; i++) {
if (pv->ldp_offsets)
file_offset = pv->ldp_offsets[i];
+
LASSERT(!(file_offset & (page_size - 1)));
clp = cl_page_find(env, obj, cl_index(obj, file_offset),
pv->ldp_pages[i], CPT_TRANSIENT);
break;
}
+ rc = cl_page_own(env, io, clp);
+ if (rc) {
+ LASSERT(clp->cp_state == CPS_FREEING);
+ cl_page_put(env, clp);
+ break;
+ }
+
+ do_io = true;
+
/* check the page type: if the page is a host page, then do
* write directly */
- /*
- * Very rare case that the host pages can be found for
- * directIO case, since linux kernel truncated all covered
- * pages before getting here. So, to make the OST happy(to
- * write a contiguous region), all pages are issued
- * here. -jay */
if (clp->cp_type == CPT_CACHEABLE) {
cfs_page_t *vmpage = cl_page_vmpage(env, clp);
cfs_page_t *src_page;
src = kmap_atomic(src_page, KM_USER0);
dst = kmap_atomic(dst_page, KM_USER1);
- memcpy(dst, (const void *)src, min(page_size, size));
+ memcpy(dst, src, min(page_size, size));
kunmap_atomic(dst, KM_USER1);
kunmap_atomic(src, KM_USER0);
* cl_io_submit()->...->vvp_page_prep_write(). */
if (rw == WRITE)
set_page_dirty(vmpage);
+
+ if (rw == READ) {
+ /* do not issue the page for read, since it
+ * may reread a ra page which has NOT uptodate
+ * bit set. */
+ cl_page_disown(env, io, clp);
+ do_io = false;
+ }
+ }
+
+ if (likely(do_io)) {
+ cl_2queue_add(queue, clp);
+
/*
- * If direct-io read finds up-to-date page in the
- * cache, just copy it to the user space. Page will be
- * filtered out by vvp_page_prep_read(). This
- * preserves an invariant, that page is read at most
- * once, see cl_page_flags::CPF_READ_COMPLETED.
+ * Set page clip to tell transfer formation engine
+ * that page has to be sent even if it is beyond KMS.
*/
- }
+ cl_page_clip(env, clp, 0, min(size, page_size));
- rc = cl_page_own(env, io, clp);
- if (rc) {
- LASSERT(clp->cp_state == CPS_FREEING);
- cl_page_put(env, clp);
- break;
+ ++io_pages;
}
- cl_2queue_add(queue, clp);
-
- /* drop the reference count for cl_page_find, so that the page
- * will be freed in cl_2queue_fini. */
+ /* drop the reference count for cl_page_find */
cl_page_put(env, clp);
- /*
- * Set page clip to tell transfer formation engine that page
- * has to be sent even if it is beyond KMS.
- */
- cl_page_clip(env, clp, 0, min(size, page_size));
size -= page_size;
file_offset += page_size;
}
- if (rc == 0) {
+ if (rc == 0 && io_pages) {
rc = cl_io_submit_sync(env, io,
rw == READ ? CRT_READ : CRT_WRITE,
queue, CRP_NORMAL, 0);
- if (rc == 0)
- rc = pv->ldp_size;
}
+ if (rc == 0)
+ rc = pv->ldp_size;
cl_2queue_discard(env, io, queue);
cl_2queue_disown(env, io, queue);
struct file *file = iocb->ki_filp;
struct inode *inode = file->f_mapping->host;
struct ccc_object *obj = cl_inode2ccc(inode);
- ssize_t count = iov_length(iov, nr_segs);
- ssize_t tot_bytes = 0, result = 0;
+ long count = iov_length(iov, nr_segs);
+ long tot_bytes = 0, result = 0;
struct ll_inode_info *lli = ll_i2info(inode);
struct lov_stripe_md *lsm = lli->lli_smd;
unsigned long seg = 0;
- size_t size = MAX_DIO_SIZE;
+ long size = MAX_DIO_SIZE;
int refcheck;
ENTRY;
if ((file_offset & ~CFS_PAGE_MASK) || (count & ~CFS_PAGE_MASK))
RETURN(-EINVAL);
- CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), size="LPSZ" (max %lu), "
- "offset=%lld=%llx, pages "LPSZ" (max %lu)\n",
+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), size=%lu (max %lu), "
+ "offset=%lld=%llx, pages %lu (max %lu)\n",
inode->i_ino, inode->i_generation, inode, count, MAX_DIO_SIZE,
file_offset, file_offset, count >> CFS_PAGE_SHIFT,
MAX_DIO_SIZE >> CFS_PAGE_SHIFT);
LASSERT(obj->cob_transient_pages == 0);
for (seg = 0; seg < nr_segs; seg++) {
- size_t iov_left = iov[seg].iov_len;
+ long iov_left = iov[seg].iov_len;
unsigned long user_addr = (unsigned long)iov[seg].iov_base;
if (rw == READ) {
while (iov_left > 0) {
struct page **pages;
int page_count, max_pages = 0;
- size_t bytes;
+ long bytes;
bytes = min(size,iov_left);
- page_count = ll_get_user_pages(rw, user_addr,
- bytes,
+ page_count = ll_get_user_pages(rw, user_addr, bytes,
&pages, &max_pages);
if (likely(page_count > 0)) {
if (unlikely(page_count < max_pages))
size = ((((size / 2) - 1) |
~CFS_PAGE_MASK) + 1) &
CFS_PAGE_MASK;
- CDEBUG(D_VFSTRACE, "DIO size now %u\n",
- (int)size);
+ CDEBUG(D_VFSTRACE,"DIO size now %lu\n",
+ size);
continue;
}
RETURN(tot_bytes ? : result);
}
+#if defined(HAVE_KERNEL_WRITE_BEGIN_END) || defined(MS_HAS_NEW_AOPS)
+static int ll_write_begin(struct file *file, struct address_space *mapping,
+ loff_t pos, unsigned len, unsigned flags,
+ struct page **pagep, void **fsdata)
+{
+ pgoff_t index = pos >> PAGE_CACHE_SHIFT;
+ struct page *page;
+ int rc;
+ unsigned from = pos & (PAGE_CACHE_SIZE - 1);
+ ENTRY;
+
+ page = grab_cache_page_write_begin(mapping, index, flags);
+ if (!page)
+ RETURN(-ENOMEM);
+
+ *pagep = page;
+
+ rc = ll_prepare_write(file, page, from, from + len);
+ if (rc) {
+ unlock_page(page);
+ page_cache_release(page);
+ }
+ RETURN(rc);
+}
+
+static int ll_write_end(struct file *file, struct address_space *mapping,
+ loff_t pos, unsigned len, unsigned copied,
+ struct page *page, void *fsdata)
+{
+ unsigned from = pos & (PAGE_CACHE_SIZE - 1);
+ int rc;
+
+ rc = ll_commit_write(file, page, from, from + copied);
+ unlock_page(page);
+ page_cache_release(page);
+
+ return rc ?: copied;
+}
+#endif
+
+#ifdef CONFIG_MIGRATION
+int ll_migratepage(struct address_space *mapping,
+ struct page *newpage, struct page *page)
+{
+ /* Always fail page migration until we have a proper implementation */
+ return -EIO;
+}
+#endif
+
+#ifndef MS_HAS_NEW_AOPS
struct address_space_operations ll_aops = {
.readpage = ll_readpage,
// .readpages = ll_readpages,
.writepages = generic_writepages,
.set_page_dirty = ll_set_page_dirty,
.sync_page = NULL,
+#ifdef HAVE_KERNEL_WRITE_BEGIN_END
+ .write_begin = ll_write_begin,
+ .write_end = ll_write_end,
+#else
.prepare_write = ll_prepare_write,
.commit_write = ll_commit_write,
+#endif
.invalidatepage = ll_invalidatepage,
.releasepage = (void *)ll_releasepage,
+#ifdef CONFIG_MIGRATION
+ .migratepage = ll_migratepage,
+#endif
.bmap = NULL
};
+#else
+struct address_space_operations_ext ll_aops = {
+ .orig_aops.readpage = ll_readpage,
+// .orig_aops.readpages = ll_readpages,
+ .orig_aops.direct_IO = ll_direct_IO_26,
+ .orig_aops.writepage = ll_writepage,
+ .orig_aops.writepages = generic_writepages,
+ .orig_aops.set_page_dirty = ll_set_page_dirty,
+ .orig_aops.sync_page = NULL,
+ .orig_aops.prepare_write = ll_prepare_write,
+ .orig_aops.commit_write = ll_commit_write,
+ .orig_aops.invalidatepage = ll_invalidatepage,
+ .orig_aops.releasepage = ll_releasepage,
+#ifdef CONFIG_MIGRATION
+ .orig_aops.migratepage = ll_migratepage,
+#endif
+ .orig_aops.bmap = NULL,
+ .write_begin = ll_write_begin,
+ .write_end = ll_write_end
+};
+#endif
git://git.whamcloud.com / fs / lustre-release.git / blobdiff