Whamcloud - gitweb
LU-709 build: clean up LC_FUNC_GRAB_CACHE_PAGE_NOWAIT_GFP
[fs/lustre-release.git] / lustre / llite / rw.c
index 7d5adcd..fee99b3 100644 (file)
@@ -28,6 +28,8 @@
 /*
  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
+ *
+ * Copyright (c) 2011, 2012, Whamcloud, Inc.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -38,7 +40,6 @@
  * Lustre Lite I/O page cache routines shared by different kernel revs
  */
 
-#include <linux/autoconf.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/string.h>
@@ -61,7 +62,6 @@
 
 #define DEBUG_SUBSYSTEM S_LLITE
 
-//#include <lustre_mdc.h>
 #include <lustre_lite.h>
 #include <obd_cksum.h>
 #include "llite_internal.h"
  * must be called under ->lli_size_sem */
 void ll_truncate(struct inode *inode)
 {
-        struct ll_inode_info *lli = ll_i2info(inode);
         ENTRY;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) to %Lu\n",inode->i_ino,
+        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) to %llu\n", inode->i_ino,
                inode->i_generation, inode, i_size_read(inode));
 
         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_TRUNC, 1);
-        if (lli->lli_size_sem_owner == cfs_current()) {
-                LASSERT_SEM_LOCKED(&lli->lli_size_sem);
-                ll_inode_size_unlock(inode, 0);
-        }
 
         EXIT;
         return;
@@ -150,7 +145,6 @@ static struct ll_cl_context *ll_cl_init(struct file *file,
         cio = ccc_env_io(env);
         io = cio->cui_cl.cis_io;
         if (io == NULL && create) {
-                struct vvp_io *vio;
                 loff_t pos;
 
                 /*
@@ -158,9 +152,7 @@ static struct ll_cl_context *ll_cl_init(struct file *file,
                  * methods directly, bypassing file system ->write() operation,
                  * so cl_io has to be created here.
                  */
-
-                io = &ccc_env_info(env)->cti_io;
-                vio = vvp_env_io(env);
+                io = ccc_env_thread_io(env);
                 ll_io_init(io, file, 1);
 
                 /* No lock at all for this kind of IO - we can't do it because
@@ -214,7 +206,7 @@ static struct ll_cl_context *ll_cl_init(struct file *file,
                 lcc = ERR_PTR(result);
         }
 
-        CDEBUG(D_VFSTRACE, "%lu@"DFID" -> %i %p %p\n",
+        CDEBUG(D_VFSTRACE, "%lu@"DFID" -> %d %p %p\n",
                vmpage->index, PFID(lu_object_fid(&clob->co_lu)), result,
                env, io);
         return lcc;
@@ -294,7 +286,7 @@ int ll_commit_write(struct file *file, struct page *vmpage, unsigned from,
         struct lu_env    *env;
         struct cl_io     *io;
         struct cl_page   *page;
-        int result;
+        int result = 0;
         ENTRY;
 
         lcc  = ll_cl_get();
@@ -303,11 +295,14 @@ int ll_commit_write(struct file *file, struct page *vmpage, unsigned from,
         io   = lcc->lcc_io;
 
         LASSERT(cl_page_is_owned(page, io));
-        result = cl_io_commit_write(env, io, page, from, to);
+        LASSERT(from <= to);
+        if (from != to) /* handle short write case. */
+                result = cl_io_commit_write(env, io, page, from, to);
         if (cl_page_is_owned(page, io))
                 cl_page_unassume(env, io, page);
+
         /*
-         * Release reference acquired by cl_io_prepare_write().
+         * Release reference acquired by ll_prepare_write().
          */
         lu_ref_del(&page->cp_reference, "prepare_write", cfs_current());
         cl_page_put(env, page);
@@ -325,35 +320,62 @@ struct obd_capa *cl_capa_lookup(struct inode *inode, enum cl_req_type crt)
 
 static void ll_ra_stats_inc_sbi(struct ll_sb_info *sbi, enum ra_stat which);
 
-/* WARNING: This algorithm is used to reduce the contention on
- * sbi->ll_lock. It should work well if the ra_max_pages is much
- * greater than the single file's read-ahead window.
+/**
+ * Get readahead pages from the filesystem readahead pool of the client for a
+ * thread.
  *
- * TODO: There may exist a `global sync problem' in this implementation.
- * Considering the global ra window is 100M, and each file's ra window is 10M,
- * there are over 10 files trying to get its ra budget and reach
- * ll_ra_count_get at the exactly same time. All of them will get a zero ra
- * window, although the global window is 100M. -jay
- */
-static unsigned long ll_ra_count_get(struct ll_sb_info *sbi, unsigned long len)
+ * /param sbi superblock for filesystem readahead state ll_ra_info
+ * /param ria per-thread readahead state
+ * /param pages number of pages requested for readahead for the thread.
+ *
+ * WARNING: This algorithm is used to reduce contention on sbi->ll_lock.
+ * It should work well if the ra_max_pages is much greater than the single
+ * file's read-ahead window, and not too many threads contending for
+ * these readahead pages.
+ *
+ * TODO: There may be a 'global sync problem' if many threads are trying
+ * to get an ra budget that is larger than the remaining readahead pages
+ * and reach here at exactly the same time. They will compute /a ret to
+ * consume the remaining pages, but will fail at atomic_add_return() and
+ * get a zero ra window, although there is still ra space remaining. - Jay */
+
+static unsigned long ll_ra_count_get(struct ll_sb_info *sbi,
+                                     struct ra_io_arg *ria,
+                                     unsigned long pages)
 {
         struct ll_ra_info *ra = &sbi->ll_ra_info;
-        unsigned long ret;
+        long ret;
         ENTRY;
 
-        /**
-         * If read-ahead pages left are less than 1M, do not do read-ahead,
+        /* If read-ahead pages left are less than 1M, do not do read-ahead,
          * otherwise it will form small read RPC(< 1M), which hurt server
-         * performance a lot.
-         */
-        ret = min(ra->ra_max_pages - cfs_atomic_read(&ra->ra_cur_pages), len);
-        if ((int)ret < 0 || ret < min((unsigned long)PTLRPC_MAX_BRW_PAGES, len))
+         * performance a lot. */
+        ret = min(ra->ra_max_pages - cfs_atomic_read(&ra->ra_cur_pages), pages);
+        if (ret < 0 || ret < min_t(long, PTLRPC_MAX_BRW_PAGES, pages))
                 GOTO(out, ret = 0);
 
+        /* If the non-strided (ria_pages == 0) readahead window
+         * (ria_start + ret) has grown across an RPC boundary, then trim
+         * readahead size by the amount beyond the RPC so it ends on an
+         * RPC boundary. If the readahead window is already ending on
+         * an RPC boundary (beyond_rpc == 0), or smaller than a full
+         * RPC (beyond_rpc < ret) the readahead size is unchanged.
+         * The (beyond_rpc != 0) check is skipped since the conditional
+         * branch is more expensive than subtracting zero from the result.
+         *
+         * Strided read is left unaligned to avoid small fragments beyond
+         * the RPC boundary from needing an extra read RPC. */
+        if (ria->ria_pages == 0) {
+                long beyond_rpc = (ria->ria_start + ret) % PTLRPC_MAX_BRW_PAGES;
+                if (/* beyond_rpc != 0 && */ beyond_rpc < ret)
+                        ret -= beyond_rpc;
+        }
+
         if (cfs_atomic_add_return(ret, &ra->ra_cur_pages) > ra->ra_max_pages) {
                 cfs_atomic_sub(ret, &ra->ra_cur_pages);
                 ret = 0;
         }
+
 out:
         RETURN(ret);
 }
@@ -503,7 +525,7 @@ static int cl_read_ahead_page(const struct lu_env *env, struct cl_io *io,
  */
 static int ll_read_ahead_page(const struct lu_env *env, struct cl_io *io,
                               struct cl_page_list *queue,
-                              int index, struct address_space *mapping)
+                              pgoff_t index, struct address_space *mapping)
 {
         struct page      *vmpage;
         struct cl_object *clob  = ll_i2info(mapping->host)->lli_clob;
@@ -519,7 +541,7 @@ static int ll_read_ahead_page(const struct lu_env *env, struct cl_io *io,
 #ifdef __GFP_NOWARN
         gfp_mask |= __GFP_NOWARN;
 #endif
-        vmpage = grab_cache_page_nowait_gfp(mapping, index, gfp_mask);
+        vmpage = grab_cache_page_nowait(mapping, index);
         if (vmpage != NULL) {
                 /* Check if vmpage was truncated or reclaimed */
                 if (vmpage->mapping == mapping) {
@@ -587,8 +609,8 @@ static unsigned long
 stride_pg_count(pgoff_t st_off, unsigned long st_len, unsigned long st_pgs,
                 unsigned long off, unsigned long length)
 {
-        unsigned long start = off > st_off ? off - st_off : 0;
-        unsigned long end = off + length > st_off ? off + length - st_off : 0;
+        __u64 start = off > st_off ? off - st_off : 0;
+        __u64 end = off + length > st_off ? off + length - st_off : 0;
         unsigned long start_left = 0;
         unsigned long end_left = 0;
         unsigned long pg_count;
@@ -606,7 +628,7 @@ stride_pg_count(pgoff_t st_off, unsigned long st_len, unsigned long st_pgs,
         if (end_left > st_pgs)
                 end_left = st_pgs;
 
-        CDEBUG(D_READA, "start %lu, end %lu start_left %lu end_left %lu \n",
+        CDEBUG(D_READA, "start "LPU64", end "LPU64" start_left %lu end_left %lu \n",
                start, end, start_left, end_left);
 
         if (start == end)
@@ -638,7 +660,8 @@ static int ras_inside_ra_window(unsigned long idx, struct ra_io_arg *ria)
          * For stride I/O mode, just check whether the idx is inside
          * the ria_pages. */
         return ria->ria_length == 0 || ria->ria_length == ria->ria_pages ||
-               (idx - ria->ria_stoff) % ria->ria_length < ria->ria_pages;
+               (idx >= ria->ria_stoff && (idx - ria->ria_stoff) %
+                ria->ria_length < ria->ria_pages);
 }
 
 static int ll_read_ahead_pages(const struct lu_env *env,
@@ -746,7 +769,7 @@ int ll_readahead(const struct lu_env *env, struct cl_io *io,
                 end = ras->ras_window_start + ras->ras_window_len - 1;
         }
         if (end != 0) {
-                unsigned long tmp_end;
+                unsigned long rpc_boundary;
                 /*
                  * Align RA window to an optimal boundary.
                  *
@@ -755,9 +778,15 @@ int ll_readahead(const struct lu_env *env, struct cl_io *io,
                  * be aligned to the RAID stripe size in the future and that
                  * is more important than the RPC size.
                  */
-                tmp_end = ((end + 1) & (~(PTLRPC_MAX_BRW_PAGES - 1))) - 1;
-                if (tmp_end > start)
-                        end = tmp_end;
+                /* Note: we only trim the RPC, instead of extending the RPC
+                 * to the boundary, so to avoid reading too much pages during
+                 * random reading. */
+                rpc_boundary = ((end + 1) & (~(PTLRPC_MAX_BRW_PAGES - 1)));
+                if (rpc_boundary > 0)
+                        rpc_boundary--;
+
+                if (rpc_boundary  > start)
+                        end = rpc_boundary;
 
                 /* Truncate RA window to end of file */
                 end = min(end, (unsigned long)((kms - 1) >> CFS_PAGE_SHIFT));
@@ -783,12 +812,13 @@ int ll_readahead(const struct lu_env *env, struct cl_io *io,
         if (len == 0)
                 RETURN(0);
 
-        reserved = ll_ra_count_get(ll_i2sbi(inode), len);
-
+        reserved = ll_ra_count_get(ll_i2sbi(inode), ria, len);
         if (reserved < len)
                 ll_ra_stats_inc(mapping, RA_STAT_MAX_IN_FLIGHT);
 
-        CDEBUG(D_READA, "reserved page %lu \n", reserved);
+        CDEBUG(D_READA, "reserved page %lu ra_cur %d ra_max %lu\n", reserved,
+               cfs_atomic_read(&ll_i2sbi(inode)->ll_ra_info.ra_cur_pages),
+               ll_i2sbi(inode)->ll_ra_info.ra_max_pages);
 
         ret = ll_read_ahead_pages(env, io, queue,
                                   ria, &reserved, mapping, &ra_end);
@@ -1119,7 +1149,7 @@ out_unlock:
         return;
 }
 
-int ll_writepage(struct page *vmpage, struct writeback_control *unused)
+int ll_writepage(struct page *vmpage, struct writeback_control *wbc)
 {
         struct inode           *inode = vmpage->mapping->host;
         struct lu_env          *env;
@@ -1141,11 +1171,11 @@ int ll_writepage(struct page *vmpage, struct writeback_control *unused)
         if (IS_ERR(env))
                 RETURN(PTR_ERR(env));
 
-        io    = &ccc_env_info(env)->cti_io;
         queue = &vvp_env_info(env)->vti_queue;
         clob  = ll_i2info(inode)->lli_clob;
         LASSERT(clob != NULL);
 
+        io = ccc_env_thread_io(env);
         io->ci_obj = clob;
         result = cl_io_init(env, io, CIT_MISC, clob);
         if (result == 0) {
@@ -1166,21 +1196,18 @@ int ll_writepage(struct page *vmpage, struct writeback_control *unused)
                         cl_2queue_init_page(queue, page);
                         result = cl_io_submit_rw(env, io, CRT_WRITE,
                                                  queue, CRP_NORMAL);
-                        cl_page_list_disown(env, io, &queue->c2_qin);
                         if (result != 0) {
                                 /*
-                                 * There is no need to clear PG_writeback, as
-                                 * cl_io_submit_rw() calls completion callback
-                                 * on failure.
-                                 */
-                                /*
                                  * Re-dirty page on error so it retries write,
                                  * but not in case when IO has actually
                                  * occurred and completed with an error.
                                  */
-                                if (!PageError(vmpage))
-                                        set_page_dirty(vmpage);
+                                if (!PageError(vmpage)) {
+                                        redirty_page_for_writepage(wbc, vmpage);
+                                        result = 0;
+                                }
                         }
+                        cl_page_list_disown(env, io, &queue->c2_qin);
                         LASSERT(!cl_page_is_owned(page, io));
                         lu_ref_del(&page->cp_reference,
                                    "writepage", cfs_current());
@@ -1217,6 +1244,7 @@ int ll_readpage(struct file *file, struct page *vmpage)
                 }
                 ll_cl_fini(lcc);
         } else {
+                unlock_page(vmpage);
                 result = PTR_ERR(lcc);
         }
         RETURN(result);