X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fllite%2Fvvp_page.c;h=76bed3cad35e4da64b23e7df21c3ef515a94523f;hb=110d8d4952a9de607cf21f648d75e0b05ef0cee1;hp=1a5dc9bf4a7536fc94a700a45ce2bea0e9fa38e9;hpb=c5361360e51de22a59d4427327bddf9fd398f352;p=fs%2Flustre-release.git

diff --git a/lustre/llite/vvp_page.c b/lustre/llite/vvp_page.c
index 1a5dc9b..76bed3c 100644
--- a/lustre/llite/vvp_page.c
+++ b/lustre/llite/vvp_page.c
@@ -1,6 +1,4 @@
-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
  * GPL HEADER START
  *
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
@@ -28,6 +26,8 @@
 /*
  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
+ *
+ * Copyright (c) 2011, 2013, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -36,6 +36,7 @@
  * Implementation of cl_page for VVP layer.
  *
  *   Author: Nikita Danilov <nikita.danilov@sun.com>
+ *   Author: Jinshan Xiong <jinshan.xiong@whamcloud.com>
  */
 
 #define DEBUG_SUBSYSTEM S_LLITE
@@ -57,38 +58,37 @@
 
 static void vvp_page_fini_common(struct ccc_page *cp)
 {
-        cfs_page_t *vmpage = cp->cpg_page;
+	struct page *vmpage = cp->cpg_page;
 
-        LASSERT(vmpage != NULL);
-        page_cache_release(vmpage);
-        OBD_SLAB_FREE_PTR(cp, vvp_page_kmem);
+	LASSERT(vmpage != NULL);
+	page_cache_release(vmpage);
 }
 
 static void vvp_page_fini(const struct lu_env *env,
-                          struct cl_page_slice *slice)
+			  struct cl_page_slice *slice)
 {
-        struct ccc_page *cp = cl2ccc_page(slice);
-        cfs_page_t *vmpage  = cp->cpg_page;
-
-        /*
-         * vmpage->private was already cleared when page was moved into
-         * VPG_FREEING state.
-         */
-        LASSERT((struct cl_page *)vmpage->private != slice->cpl_page);
-        vvp_page_fini_common(cp);
+	struct ccc_page *cp = cl2ccc_page(slice);
+	struct page *vmpage  = cp->cpg_page;
+
+	/*
+	 * vmpage->private was already cleared when page was moved into
+	 * VPG_FREEING state.
+	 */
+	LASSERT((struct cl_page *)vmpage->private != slice->cpl_page);
+	vvp_page_fini_common(cp);
 }
 
 static int vvp_page_own(const struct lu_env *env,
                         const struct cl_page_slice *slice, struct cl_io *io,
                         int nonblock)
 {
-        struct ccc_page *vpg    = cl2ccc_page(slice);
-        cfs_page_t      *vmpage = vpg->cpg_page;
+	struct ccc_page *vpg    = cl2ccc_page(slice);
+	struct page      *vmpage = vpg->cpg_page;
 
-        LASSERT(vmpage != NULL);
-        if (nonblock) {
-                if (TestSetPageLocked(vmpage))
-                        return -EAGAIN;
+	LASSERT(vmpage != NULL);
+	if (nonblock) {
+		if (!trylock_page(vmpage))
+			return -EAGAIN;
 
                 if (unlikely(PageWriteback(vmpage))) {
                         unlock_page(vmpage);
@@ -104,106 +104,104 @@ static int vvp_page_own(const struct lu_env *env,
 }
 
 static void vvp_page_assume(const struct lu_env *env,
-                            const struct cl_page_slice *slice,
-                            struct cl_io *unused)
+			    const struct cl_page_slice *slice,
+			    struct cl_io *unused)
 {
-        cfs_page_t *vmpage = cl2vm_page(slice);
+	struct page *vmpage = cl2vm_page(slice);
 
-        LASSERT(vmpage != NULL);
-        LASSERT(PageLocked(vmpage));
-        wait_on_page_writeback(vmpage);
+	LASSERT(vmpage != NULL);
+	LASSERT(PageLocked(vmpage));
+	wait_on_page_writeback(vmpage);
 }
 
 static void vvp_page_unassume(const struct lu_env *env,
-                              const struct cl_page_slice *slice,
-                              struct cl_io *unused)
+			      const struct cl_page_slice *slice,
+			      struct cl_io *unused)
 {
-        cfs_page_t *vmpage = cl2vm_page(slice);
+	struct page *vmpage = cl2vm_page(slice);
 
-        LASSERT(vmpage != NULL);
-        LASSERT(PageLocked(vmpage));
+	LASSERT(vmpage != NULL);
+	LASSERT(PageLocked(vmpage));
 }
 
 static void vvp_page_disown(const struct lu_env *env,
-                            const struct cl_page_slice *slice, struct cl_io *io)
+			    const struct cl_page_slice *slice, struct cl_io *io)
 {
-        cfs_page_t *vmpage = cl2vm_page(slice);
+	struct page *vmpage = cl2vm_page(slice);
 
-        LASSERT(vmpage != NULL);
-        LASSERT(PageLocked(vmpage));
+	LASSERT(vmpage != NULL);
+	LASSERT(PageLocked(vmpage));
 
-        unlock_page(cl2vm_page(slice));
+	unlock_page(cl2vm_page(slice));
 }
 
 static void vvp_page_discard(const struct lu_env *env,
                              const struct cl_page_slice *slice,
                              struct cl_io *unused)
 {
-        cfs_page_t           *vmpage  = cl2vm_page(slice);
-        struct address_space *mapping = vmpage->mapping;
-        struct ccc_page      *cpg     = cl2ccc_page(slice);
+	struct page          *vmpage  = cl2vm_page(slice);
+	struct address_space *mapping;
+	struct ccc_page      *cpg     = cl2ccc_page(slice);
+	__u64 offset;
 
-        LASSERT(vmpage != NULL);
-        LASSERT(PageLocked(vmpage));
+	LASSERT(vmpage != NULL);
+	LASSERT(PageLocked(vmpage));
 
-        if (cpg->cpg_defer_uptodate && !cpg->cpg_ra_used)
-                ll_ra_stats_inc(mapping, RA_STAT_DISCARDED);
+	mapping = vmpage->mapping;
 
-        /*
-         * truncate_complete_page() calls
-         * a_ops->invalidatepage()->cl_page_delete()->vvp_page_delete().
-         */
-        truncate_complete_page(mapping, vmpage);
-}
+	if (cpg->cpg_defer_uptodate && !cpg->cpg_ra_used)
+		ll_ra_stats_inc(mapping, RA_STAT_DISCARDED);
 
-static int vvp_page_unmap(const struct lu_env *env,
-                          const struct cl_page_slice *slice,
-                          struct cl_io *unused)
-{
-        cfs_page_t *vmpage = cl2vm_page(slice);
-        __u64       offset = vmpage->index << CFS_PAGE_SHIFT;
+	offset = vmpage->index << PAGE_SHIFT;
+	ll_teardown_mmaps(vmpage->mapping, offset, offset + PAGE_SIZE);
 
-        LASSERT(vmpage != NULL);
-        LASSERT(PageLocked(vmpage));
-        /*
-         * XXX is it safe to call this with the page lock held?
-         */
-        ll_teardown_mmaps(vmpage->mapping, offset, offset + CFS_PAGE_SIZE);
-        return 0;
+	/*
+	 * truncate_complete_page() calls
+	 * a_ops->invalidatepage()->cl_page_delete()->vvp_page_delete().
+	 */
+	truncate_complete_page(mapping, vmpage);
 }
 
 static void vvp_page_delete(const struct lu_env *env,
                             const struct cl_page_slice *slice)
 {
-        cfs_page_t       *vmpage = cl2vm_page(slice);
-        struct inode     *inode  = vmpage->mapping->host;
-        struct cl_object *obj    = slice->cpl_obj;
-
-        LASSERT(PageLocked(vmpage));
-        LASSERT((struct cl_page *)vmpage->private == slice->cpl_page);
-        LASSERT(inode == ccc_object_inode(obj));
-
-        vvp_write_complete(cl2ccc(obj), cl2ccc_page(slice));
-        ClearPagePrivate(vmpage);
-        vmpage->private = 0;
-        /*
-         * Reference from vmpage to cl_page is removed, but the reference back
-         * is still here. It is removed later in vvp_page_fini().
-         */
+	struct page      *vmpage = cl2vm_page(slice);
+	struct inode     *inode  = vmpage->mapping->host;
+	struct cl_object *obj    = slice->cpl_obj;
+	struct cl_page   *page   = slice->cpl_page;
+	int refc;
+
+	LASSERT(PageLocked(vmpage));
+	LASSERT((struct cl_page *)vmpage->private == page);
+	LASSERT(inode == ccc_object_inode(obj));
+
+	vvp_write_complete(cl2ccc(obj), cl2ccc_page(slice));
+
+	/* Drop the reference count held in vvp_page_init */
+	refc = atomic_dec_return(&page->cp_ref);
+	LASSERTF(refc >= 1, "page = %p, refc = %d\n", page, refc);
+
+	ClearPageUptodate(vmpage);
+	ClearPagePrivate(vmpage);
+	vmpage->private = 0;
+	/*
+	 * Reference from vmpage to cl_page is removed, but the reference back
+	 * is still here. It is removed later in vvp_page_fini().
+	 */
 }
 
 static void vvp_page_export(const struct lu_env *env,
-                            const struct cl_page_slice *slice,
-                            int uptodate)
+			    const struct cl_page_slice *slice,
+			    int uptodate)
 {
-        cfs_page_t *vmpage = cl2vm_page(slice);
-
-        LASSERT(vmpage != NULL);
-        LASSERT(PageLocked(vmpage));
-        if (uptodate)
-                SetPageUptodate(vmpage);
-        else
-                ClearPageUptodate(vmpage);
+	struct page *vmpage = cl2vm_page(slice);
+
+	LASSERT(vmpage != NULL);
+	LASSERT(PageLocked(vmpage));
+	if (uptodate)
+		SetPageUptodate(vmpage);
+	else
+		ClearPageUptodate(vmpage);
 }
 
 static int vvp_page_is_vmlocked(const struct lu_env *env,
@@ -225,21 +223,15 @@ static int vvp_page_prep_write(const struct lu_env *env,
                                const struct cl_page_slice *slice,
                                struct cl_io *unused)
 {
-        struct cl_page *cp     = slice->cpl_page;
-        cfs_page_t     *vmpage = cl2vm_page(slice);
-        int result;
+	struct page *vmpage = cl2vm_page(slice);
 
-        if (clear_page_dirty_for_io(vmpage)) {
-                set_page_writeback(vmpage);
-                vvp_write_pending(cl2ccc(slice->cpl_obj), cl2ccc_page(slice));
-                result = 0;
+	LASSERT(PageLocked(vmpage));
+	LASSERT(!PageDirty(vmpage));
 
-                /* only turn on writeback for async write. */
-                if (cp->cp_sync_io == NULL)
-                        unlock_page(vmpage);
-        } else
-                result = -EALREADY;
-        return result;
+	set_page_writeback(vmpage);
+	vvp_write_pending(cl2ccc(slice->cpl_obj), cl2ccc_page(slice));
+
+	return 0;
 }
 
 /**
@@ -248,17 +240,26 @@ static int vvp_page_prep_write(const struct lu_env *env,
  * This takes inode as a separate argument, because inode on which error is to
  * be set can be different from \a vmpage inode in case of direct-io.
  */
-static void vvp_vmpage_error(struct inode *inode, cfs_page_t *vmpage, int ioret)
+static void vvp_vmpage_error(struct inode *inode, struct page *vmpage, int ioret)
 {
-        if (ioret == 0)
-                ClearPageError(vmpage);
-        else if (ioret != -EINTR) {
-                SetPageError(vmpage);
-                if (ioret == -ENOSPC)
-                        set_bit(AS_ENOSPC, &inode->i_mapping->flags);
-                else
-                        set_bit(AS_EIO, &inode->i_mapping->flags);
-        }
+	struct ccc_object *obj = cl_inode2ccc(inode);
+
+	if (ioret == 0) {
+		ClearPageError(vmpage);
+		obj->cob_discard_page_warned = 0;
+	} else {
+		SetPageError(vmpage);
+		if (ioret == -ENOSPC)
+			set_bit(AS_ENOSPC, &inode->i_mapping->flags);
+		else
+			set_bit(AS_EIO, &inode->i_mapping->flags);
+
+		if ((ioret == -ESHUTDOWN || ioret == -EINTR) &&
+		     obj->cob_discard_page_warned == 0) {
+			obj->cob_discard_page_warned = 1;
+			ll_dirty_page_discard_warn(vmpage, ioret);
+		}
+	}
 }
 
 static void vvp_page_completion_read(const struct lu_env *env,
@@ -266,7 +267,7 @@ static void vvp_page_completion_read(const struct lu_env *env,
                                      int ioret)
 {
         struct ccc_page *cp     = cl2ccc_page(slice);
-        cfs_page_t      *vmpage = cp->cpg_page;
+	struct page      *vmpage = cp->cpg_page;
         struct cl_page  *page   = cl_page_top(slice->cpl_page);
         struct inode    *inode  = ccc_object_inode(page->cp_obj);
         ENTRY;
@@ -293,10 +294,10 @@ static void vvp_page_completion_write(const struct lu_env *env,
                                       const struct cl_page_slice *slice,
                                       int ioret)
 {
-        struct ccc_page *cp     = cl2ccc_page(slice);
-        struct cl_page  *pg     = slice->cpl_page;
-        cfs_page_t      *vmpage = cp->cpg_page;
-        ENTRY;
+	struct ccc_page *cp     = cl2ccc_page(slice);
+	struct cl_page  *pg     = slice->cpl_page;
+	struct page      *vmpage = cp->cpg_page;
+	ENTRY;
 
         LASSERT(ergo(pg->cp_sync_io != NULL, PageLocked(vmpage)));
         LASSERT(PageWriteback(vmpage));
@@ -342,45 +343,40 @@ static void vvp_page_completion_write(const struct lu_env *env,
  * truncated. Skip it.
  */
 static int vvp_page_make_ready(const struct lu_env *env,
-                               const struct cl_page_slice *slice)
+			       const struct cl_page_slice *slice)
 {
-        cfs_page_t *vmpage = cl2vm_page(slice);
-        struct cl_page *pg = slice->cpl_page;
-        int result;
-
-        result = -EAGAIN;
-        /* we're trying to write, but the page is locked.. come back later */
-        if (!TestSetPageLocked(vmpage)) {
-                if (pg->cp_state == CPS_CACHED) {
-                        /*
-                         * We can cancel IO if page wasn't dirty after all.
-                         */
-                        clear_page_dirty_for_io(vmpage);
-                        /*
-                         * This actually clears the dirty bit in the radix
-                         * tree.
-                         */
-                        set_page_writeback(vmpage);
-                        vvp_write_pending(cl2ccc(slice->cpl_obj),
-                                          cl2ccc_page(slice));
-                        CL_PAGE_HEADER(D_PAGE, env, pg, "readied\n");
-                        result = 0;
-                } else
-                        /*
-                         * Page was concurrently truncated.
-                         */
-                        LASSERT(pg->cp_state == CPS_FREEING);
-                unlock_page(vmpage);
-        }
-        RETURN(result);
+	struct page *vmpage = cl2vm_page(slice);
+	struct cl_page *pg = slice->cpl_page;
+	int result = 0;
+
+	lock_page(vmpage);
+	if (clear_page_dirty_for_io(vmpage)) {
+		LASSERT(pg->cp_state == CPS_CACHED);
+		/* This actually clears the dirty bit in the radix
+		 * tree. */
+		set_page_writeback(vmpage);
+		vvp_write_pending(cl2ccc(slice->cpl_obj),
+				cl2ccc_page(slice));
+		CL_PAGE_HEADER(D_PAGE, env, pg, "readied\n");
+	} else if (pg->cp_state == CPS_PAGEOUT) {
+		/* is it possible for osc_flush_async_page() to already
+		 * make it ready? */
+		result = -EALREADY;
+	} else {
+		CL_PAGE_DEBUG(D_ERROR, env, pg, "Unexpecting page state %d.\n",
+			      pg->cp_state);
+		LBUG();
+	}
+	unlock_page(vmpage);
+	RETURN(result);
 }
 
 static int vvp_page_print(const struct lu_env *env,
                           const struct cl_page_slice *slice,
                           void *cookie, lu_printer_t printer)
 {
-        struct ccc_page *vp = cl2ccc_page(slice);
-        cfs_page_t      *vmpage = vp->cpg_page;
+	struct ccc_page *vp = cl2ccc_page(slice);
+	struct page      *vmpage = vp->cpg_page;
 
         (*printer)(env, cookie, LUSTRE_VVP_NAME"-page@%p(%d:%d:%d) "
                    "vm@%p ",
@@ -405,7 +401,6 @@ static const struct cl_page_operations vvp_page_ops = {
         .cpo_vmpage        = ccc_page_vmpage,
         .cpo_discard       = vvp_page_discard,
         .cpo_delete        = vvp_page_delete,
-        .cpo_unmap         = vvp_page_unmap,
         .cpo_export        = vvp_page_export,
         .cpo_is_vmlocked   = vvp_page_is_vmlocked,
         .cpo_fini          = vvp_page_fini,
@@ -427,10 +422,9 @@ static const struct cl_page_operations vvp_page_ops = {
 
 static void vvp_transient_page_verify(const struct cl_page *page)
 {
-        struct inode *inode = ccc_object_inode(page->cp_obj);
+	struct inode *inode = ccc_object_inode(page->cp_obj);
 
-        LASSERT(!TRYLOCK_INODE_MUTEX(inode));
-        /* LASSERT_SEM_LOCKED(&inode->i_alloc_sem); */
+	LASSERT(!mutex_trylock(&inode->i_mutex));
 }
 
 static int vvp_transient_page_own(const struct lu_env *env,
@@ -477,15 +471,15 @@ static void vvp_transient_page_discard(const struct lu_env *env,
 }
 
 static int vvp_transient_page_is_vmlocked(const struct lu_env *env,
-                                          const struct cl_page_slice *slice)
+					  const struct cl_page_slice *slice)
 {
-        struct inode    *inode = ccc_object_inode(slice->cpl_obj);
-        int              locked;
+	struct inode    *inode = ccc_object_inode(slice->cpl_obj);
+	int	locked;
 
-        locked = !TRYLOCK_INODE_MUTEX(inode);
-        if (!locked)
-                UNLOCK_INODE_MUTEX(inode);
-        return locked ? -EBUSY : -ENODATA;
+	locked = !mutex_trylock(&inode->i_mutex);
+	if (!locked)
+		mutex_unlock(&inode->i_mutex);
+	return locked ? -EBUSY : -ENODATA;
 }
 
 static void
@@ -497,15 +491,15 @@ vvp_transient_page_completion(const struct lu_env *env,
 }
 
 static void vvp_transient_page_fini(const struct lu_env *env,
-                                    struct cl_page_slice *slice)
+				    struct cl_page_slice *slice)
 {
-        struct ccc_page *cp = cl2ccc_page(slice);
-        struct cl_page *clp = slice->cpl_page;
-        struct ccc_object *clobj = cl2ccc(clp->cp_obj);
+	struct ccc_page *cp = cl2ccc_page(slice);
+	struct cl_page *clp = slice->cpl_page;
+	struct ccc_object *clobj = cl2ccc(clp->cp_obj);
 
-        vvp_page_fini_common(cp);
-        LASSERT(!TRYLOCK_INODE_MUTEX(clobj->cob_inode));
-        clobj->cob_transient_pages--;
+	vvp_page_fini_common(cp);
+	LASSERT(!mutex_trylock(&clobj->cob_inode->i_mutex));
+	clobj->cob_transient_pages--;
 }
 
 static const struct cl_page_operations vvp_transient_page_ops = {
@@ -531,36 +525,32 @@ static const struct cl_page_operations vvp_transient_page_ops = {
         }
 };
 
-struct cl_page *vvp_page_init(const struct lu_env *env, struct cl_object *obj,
-                              struct cl_page *page, cfs_page_t *vmpage)
+int vvp_page_init(const struct lu_env *env, struct cl_object *obj,
+		struct cl_page *page, struct page *vmpage)
 {
-        struct ccc_page *cpg;
-        int result;
-
-        CLOBINVRNT(env, obj, ccc_object_invariant(obj));
-
-        OBD_SLAB_ALLOC_PTR_GFP(cpg, vvp_page_kmem, CFS_ALLOC_IO);
-        if (cpg != NULL) {
-                cpg->cpg_page = vmpage;
-                page_cache_get(vmpage);
-
-                CFS_INIT_LIST_HEAD(&cpg->cpg_pending_linkage);
-                if (page->cp_type == CPT_CACHEABLE) {
-                        SetPagePrivate(vmpage);
-                        vmpage->private = (unsigned long)page;
-                        cl_page_slice_add(page, &cpg->cpg_cl, obj,
-                                          &vvp_page_ops);
-                } else {
-                        struct ccc_object *clobj = cl2ccc(obj);
-
-                        LASSERT(!TRYLOCK_INODE_MUTEX(clobj->cob_inode));
-                        cl_page_slice_add(page, &cpg->cpg_cl, obj,
-                                          &vvp_transient_page_ops);
-                        clobj->cob_transient_pages++;
-                }
-                result = 0;
-        } else
-                result = -ENOMEM;
-        return ERR_PTR(result);
+	struct ccc_page *cpg = cl_object_page_slice(obj, page);
+
+	CLOBINVRNT(env, obj, ccc_object_invariant(obj));
+
+	cpg->cpg_page = vmpage;
+	page_cache_get(vmpage);
+
+	CFS_INIT_LIST_HEAD(&cpg->cpg_pending_linkage);
+	if (page->cp_type == CPT_CACHEABLE) {
+		/* in cache, decref in vvp_page_delete */
+		atomic_inc(&page->cp_ref);
+		SetPagePrivate(vmpage);
+		vmpage->private = (unsigned long)page;
+		cl_page_slice_add(page, &cpg->cpg_cl, obj,
+				&vvp_page_ops);
+	} else {
+		struct ccc_object *clobj = cl2ccc(obj);
+
+		LASSERT(!mutex_trylock(&clobj->cob_inode->i_mutex));
+		cl_page_slice_add(page, &cpg->cpg_cl, obj,
+				&vvp_transient_page_ops);
+		clobj->cob_transient_pages++;
+	}
+	return 0;
 }