X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Flov%2Flov_page.c;h=2b9d54a0a949a0b1f8b85c51b5dedd2806d79335;hp=b995e7d4fa4a8d92c528b808528ac7bad9423fa6;hb=8d6d2914cf85be0508805cd5195163e1959652f4;hpb=65701b4a30efdb695776bcf690a2b3cabc928da1 diff --git a/lustre/lov/lov_page.c b/lustre/lov/lov_page.c index b995e7d..2b9d54a 100644 --- a/lustre/lov/lov_page.c +++ b/lustre/lov/lov_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. @@ -17,11 +15,7 @@ * * You should have received a copy of the GNU General Public License * version 2 along with this program; If not, see - * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf - * - * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. + * http://www.gnu.org/licenses/gpl-2.0.html * * GPL HEADER END */ @@ -29,7 +23,7 @@ * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, Whamcloud, Inc. + * Copyright (c) 2011, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -38,6 +32,7 @@ * Implementation of cl_page for LOV layer. * * Author: Nikita Danilov + * Author: Jinshan Xiong */ #define DEBUG_SUBSYSTEM S_LOV @@ -54,174 +49,118 @@ * */ -static int lov_page_invariant(const struct cl_page_slice *slice) +static int lov_comp_page_print(const struct lu_env *env, + const struct cl_page_slice *slice, + void *cookie, lu_printer_t printer) { - const struct cl_page *page = slice->cpl_page; - const struct cl_page *sub = lov_sub_page(slice); - - return ergo(sub != NULL, - page->cp_child == sub && - sub->cp_parent == page && - page->cp_state == sub->cp_state); -} + struct lov_page *lp = cl2lov_page(slice); -static void lov_page_fini(const struct lu_env *env, - struct cl_page_slice *slice) -{ - struct lov_page *lp = cl2lov_page(slice); - struct cl_page *sub = lov_sub_page(slice); - - LINVRNT(lov_page_invariant(slice)); - ENTRY; - - if (sub != NULL) { - LASSERT(sub->cp_state == CPS_FREEING); - lu_ref_del(&sub->cp_reference, "lov", sub->cp_parent); - sub->cp_parent = NULL; - slice->cpl_page->cp_child = NULL; - cl_page_put(env, sub); - } - OBD_SLAB_FREE_PTR(lp, lov_page_kmem); - EXIT; + return (*printer)(env, cookie, + LUSTRE_LOV_NAME"-page@%p, gen: %u\n", + lp, lp->lps_layout_gen); } -static int lov_page_own(const struct lu_env *env, - const struct cl_page_slice *slice, struct cl_io *io, - int nonblock) -{ - struct lov_io *lio = lov_env_io(env); - struct lov_io_sub *sub; - - LINVRNT(lov_page_invariant(slice)); - LINVRNT(!cl2lov_page(slice)->lps_invalid); - ENTRY; - - sub = lov_page_subio(env, lio, slice); - if (!IS_ERR(sub)) { - lov_sub_page(slice)->cp_owner = sub->sub_io; - lov_sub_put(sub); - } else - LBUG(); /* Arrgh */ - RETURN(0); -} +static const struct cl_page_operations lov_comp_page_ops = { + .cpo_print = lov_comp_page_print +}; -static void lov_page_assume(const struct lu_env *env, - const struct cl_page_slice *slice, struct cl_io *io) +int lov_page_init_composite(const struct lu_env *env, struct cl_object *obj, + struct cl_page *page, pgoff_t index) { - lov_page_own(env, slice, io, 0); + struct lov_object *loo = cl2lov(obj); + struct lov_io *lio = lov_env_io(env); + struct cl_object *subobj; + struct cl_object *o; + struct lov_io_sub *sub; + struct lov_page *lpg = cl_object_page_slice(obj, page); + struct lov_layout_raid0 *r0; + loff_t offset; + loff_t suboff; + int entry; + int stripe; + int rc; + + ENTRY; + + offset = cl_offset(obj, index); + entry = lov_io_layout_at(lio, offset); + if (entry < 0 || !lsm_entry_inited(loo->lo_lsm, entry)) { + /* non-existing layout component */ + lov_page_init_empty(env, obj, page, index); + RETURN(0); + } + + r0 = lov_r0(loo, entry); + stripe = lov_stripe_number(loo->lo_lsm, entry, offset); + LASSERT(stripe < r0->lo_nr); + rc = lov_stripe_offset(loo->lo_lsm, entry, offset, stripe, &suboff); + LASSERT(rc == 0); + + page->cp_lov_index = lov_comp_index(entry, stripe); + lpg->lps_layout_gen = loo->lo_lsm->lsm_layout_gen; + cl_page_slice_add(page, &lpg->lps_cl, obj, index, &lov_comp_page_ops); + + sub = lov_sub_get(env, lio, page->cp_lov_index); + if (IS_ERR(sub)) + RETURN(PTR_ERR(sub)); + + subobj = lovsub2cl(r0->lo_sub[stripe]); + list_for_each_entry(o, &subobj->co_lu.lo_header->loh_layers, + co_lu.lo_linkage) { + if (o->co_ops->coo_page_init) { + rc = o->co_ops->coo_page_init(sub->sub_env, o, page, + cl_index(subobj, suboff)); + if (rc != 0) + break; + } + } + + RETURN(rc); } -static int lov_page_print(const struct lu_env *env, - const struct cl_page_slice *slice, - void *cookie, lu_printer_t printer) +static int lov_empty_page_print(const struct lu_env *env, + const struct cl_page_slice *slice, + void *cookie, lu_printer_t printer) { - struct lov_page *lp = cl2lov_page(slice); + struct lov_page *lp = cl2lov_page(slice); - return (*printer)(env, cookie, LUSTRE_LOV_NAME"-page@%p\n", lp); + return (*printer)(env, cookie, LUSTRE_LOV_NAME"-page@%p, empty.\n", lp); } -static const struct cl_page_operations lov_page_ops = { - .cpo_fini = lov_page_fini, - .cpo_own = lov_page_own, - .cpo_assume = lov_page_assume, - .cpo_print = lov_page_print +static const struct cl_page_operations lov_empty_page_ops = { + .cpo_print = lov_empty_page_print }; -static void lov_empty_page_fini(const struct lu_env *env, - struct cl_page_slice *slice) +int lov_page_init_empty(const struct lu_env *env, struct cl_object *obj, + struct cl_page *page, pgoff_t index) { - struct lov_page *lp = cl2lov_page(slice); - - LASSERT(slice->cpl_page->cp_child == NULL); - ENTRY; - OBD_SLAB_FREE_PTR(lp, lov_page_kmem); - EXIT; + struct lov_page *lpg = cl_object_page_slice(obj, page); + void *addr; + + ENTRY; + + page->cp_lov_index = ~0; + cl_page_slice_add(page, &lpg->lps_cl, obj, index, &lov_empty_page_ops); + addr = kmap(page->cp_vmpage); + memset(addr, 0, cl_page_size(obj)); + kunmap(page->cp_vmpage); + cl_page_export(env, page, 1); + RETURN(0); } -struct cl_page *lov_page_init_raid0(const struct lu_env *env, - struct cl_object *obj, struct cl_page *page, - cfs_page_t *vmpage) +int lov_page_init_foreign(const struct lu_env *env, struct cl_object *obj, + struct cl_page *page, pgoff_t index) { - struct lov_object *loo = cl2lov(obj); - struct lov_layout_raid0 *r0 = lov_r0(loo); - struct lov_io *lio = lov_env_io(env); - struct cl_page *subpage; - struct cl_object *subobj; - struct lov_io_sub *sub; - struct lov_page *lpg; - struct cl_page *result; - loff_t offset; - obd_off suboff; - int stripe; - int rc; - ENTRY; - - offset = cl_offset(obj, page->cp_index); - stripe = lov_stripe_number(r0->lo_lsm, offset); - LASSERT(stripe < r0->lo_nr); - rc = lov_stripe_offset(r0->lo_lsm, offset, stripe, - &suboff); - LASSERT(rc == 0); - - OBD_SLAB_ALLOC_PTR_GFP(lpg, lov_page_kmem, CFS_ALLOC_IO); - if (lpg == NULL) - GOTO(out, result = ERR_PTR(-ENOMEM)); - - lpg->lps_invalid = 1; - cl_page_slice_add(page, &lpg->lps_cl, obj, &lov_page_ops); - - sub = lov_sub_get(env, lio, stripe); - if (IS_ERR(sub)) - GOTO(out, result = (struct cl_page *)sub); - - subobj = lovsub2cl(r0->lo_sub[stripe]); - subpage = cl_page_find_sub(sub->sub_env, subobj, - cl_index(subobj, suboff), vmpage, page); - lov_sub_put(sub); - if (IS_ERR(subpage)) - GOTO(out, result = subpage); - - if (likely(subpage->cp_parent == page)) { - lu_ref_add(&subpage->cp_reference, "lov", page); - lpg->lps_invalid = 0; - result = NULL; - } else { - CL_PAGE_DEBUG(D_ERROR, env, page, "parent page\n"); - CL_PAGE_DEBUG(D_ERROR, env, subpage, "child page\n"); - LASSERT(0); - } - - EXIT; -out: - return(result); + CDEBUG(D_PAGE, DFID" has no data\n", PFID(lu_object_fid(&obj->co_lu))); + RETURN(-ENODATA); } - -static const struct cl_page_operations lov_empty_page_ops = { - .cpo_fini = lov_empty_page_fini, - .cpo_print = lov_page_print -}; - -struct cl_page *lov_page_init_empty(const struct lu_env *env, - struct cl_object *obj, struct cl_page *page, - cfs_page_t *vmpage) +bool lov_page_is_empty(const struct cl_page *page) { - struct lov_page *lpg; - int result = -ENOMEM; - ENTRY; - - OBD_SLAB_ALLOC_PTR_GFP(lpg, lov_page_kmem, CFS_ALLOC_IO); - if (lpg != NULL) { - void *addr; - cl_page_slice_add(page, &lpg->lps_cl, - obj, &lov_empty_page_ops); - addr = cfs_kmap(vmpage); - memset(addr, 0, cl_page_size(obj)); - cfs_kunmap(vmpage); - cl_page_export(env, page, 1); - result = 0; - } - RETURN(ERR_PTR(result)); + const struct cl_page_slice *slice = cl_page_at(page, &lov_device_type); + + LASSERT(slice != NULL); + return slice->cpl_ops == &lov_empty_page_ops; }