X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Finclude%2Flustre_mdc.h;h=8b10c647d6e2078465f7dda31c8af8cfc71c657e;hb=db89ce2c7e38656817f9a374f33d6963ff81851c;hp=598754b73ce77068840298e781815fd99e7ded7f;hpb=3192e52a89946f12fd36d28a686c169d01d36e64;p=fs%2Flustre-release.git diff --git a/lustre/include/lustre_mdc.h b/lustre/include/lustre_mdc.h index 598754b..8b10c64 100644 --- a/lustre/include/lustre_mdc.h +++ b/lustre/include/lustre_mdc.h @@ -1,7 +1,40 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: +/* + * GPL HEADER START * - * This file is part of Lustre, http://www.lustre.org + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 only, + * as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License version 2 for more details (a copy is included + * in the LICENSE file that accompanied this code). + * + * 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. + * + * GPL HEADER END + */ +/* + * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. + * Use is subject to license terms. + */ +/* + * Copyright (c) 2012 Whamcloud, Inc. + */ +/* + * This file is part of Lustre, http://www.lustre.org/ + * Lustre is a trademark of Sun Microsystems, Inc. + * + * lustre/include/lustre_mdc.h * * MDS data structures. * See also lustre_idl.h for wire formats of requests. @@ -10,23 +43,21 @@ #ifndef _LUSTRE_MDC_H #define _LUSTRE_MDC_H +/** \defgroup mdc mdc + * + * @{ + */ + #ifdef __KERNEL__ # include # include # ifdef CONFIG_FS_POSIX_ACL -# ifdef HAVE_XATTR_ACL -# include -# endif /*HAVE_XATTR_ACL */ -# ifdef HAVE_LINUX_POSIX_ACL_XATTR_H -# include -# endif /* HAVE_LINUX_POSIX_ACL_XATTR_H */ +# include # endif /* CONFIG_FS_POSIX_ACL */ -# ifndef HAVE_VFS_INTENT_PATCHES # include -# endif /* HAVE_VFS_INTENT_PATCHES */ #endif /* __KERNEL__ */ #include -#include +#include #include #include #include @@ -39,41 +70,101 @@ struct ptlrpc_request; struct obd_device; struct mdc_rpc_lock { - struct semaphore rpcl_sem; - struct lookup_intent *rpcl_it; + cfs_mutex_t rpcl_mutex; + struct lookup_intent *rpcl_it; + int rpcl_fakes; }; +#define MDC_FAKE_RPCL_IT ((void *)0x2c0012bfUL) + static inline void mdc_init_rpc_lock(struct mdc_rpc_lock *lck) { - sema_init(&lck->rpcl_sem, 1); + cfs_mutex_init(&lck->rpcl_mutex); lck->rpcl_it = NULL; } static inline void mdc_get_rpc_lock(struct mdc_rpc_lock *lck, - struct lookup_intent *it) + struct lookup_intent *it) { - ENTRY; - if (!it || (it->it_op != IT_GETATTR && it->it_op != IT_LOOKUP)) { - down(&lck->rpcl_sem); - LASSERT(lck->rpcl_it == NULL); - lck->rpcl_it = it; - } + ENTRY; + + if (it != NULL && (it->it_op == IT_GETATTR || it->it_op == IT_LOOKUP)) + return; + + /* This would normally block until the existing request finishes. + * If fail_loc is set it will block until the regular request is + * done, then set rpcl_it to MDC_FAKE_RPCL_IT. Once that is set + * it will only be cleared when all fake requests are finished. + * Only when all fake requests are finished can normal requests + * be sent, to ensure they are recoverable again. */ + again: + cfs_mutex_lock(&lck->rpcl_mutex); + + if (CFS_FAIL_CHECK_QUIET(OBD_FAIL_MDC_RPCS_SEM)) { + lck->rpcl_it = MDC_FAKE_RPCL_IT; + lck->rpcl_fakes++; + cfs_mutex_unlock(&lck->rpcl_mutex); + return; + } + + /* This will only happen when the CFS_FAIL_CHECK() was + * just turned off but there are still requests in progress. + * Wait until they finish. It doesn't need to be efficient + * in this extremely rare case, just have low overhead in + * the common case when it isn't true. */ + while (unlikely(lck->rpcl_it == MDC_FAKE_RPCL_IT)) { + cfs_mutex_unlock(&lck->rpcl_mutex); + cfs_schedule_timeout(cfs_time_seconds(1) / 4); + goto again; + } + + LASSERT(lck->rpcl_it == NULL); + lck->rpcl_it = it; } static inline void mdc_put_rpc_lock(struct mdc_rpc_lock *lck, - struct lookup_intent *it) + struct lookup_intent *it) { - if (!it || (it->it_op != IT_GETATTR && it->it_op != IT_LOOKUP)) { - LASSERT(it == lck->rpcl_it); - lck->rpcl_it = NULL; - up(&lck->rpcl_sem); + if (it != NULL && (it->it_op == IT_GETATTR || it->it_op == IT_LOOKUP)) + goto out; + + if (lck->rpcl_it == MDC_FAKE_RPCL_IT) { /* OBD_FAIL_MDC_RPCS_SEM */ + cfs_mutex_lock(&lck->rpcl_mutex); + + LASSERTF(lck->rpcl_fakes > 0, "%d\n", lck->rpcl_fakes); + lck->rpcl_fakes--; + + if (lck->rpcl_fakes == 0) + lck->rpcl_it = NULL; + + } else { + LASSERTF(it == lck->rpcl_it, "%p != %p\n", it, lck->rpcl_it); + lck->rpcl_it = NULL; + } + + cfs_mutex_unlock(&lck->rpcl_mutex); + out: + EXIT; +} + +static inline void mdc_update_max_ea_from_body(struct obd_export *exp, + struct mdt_body *body) +{ + if (body->valid & OBD_MD_FLMODEASIZE) { + if (exp->exp_obd->u.cli.cl_max_mds_easize < body->max_mdsize) + exp->exp_obd->u.cli.cl_max_mds_easize = + body->max_mdsize; + if (exp->exp_obd->u.cli.cl_max_mds_cookiesize < + body->max_cookiesize) + exp->exp_obd->u.cli.cl_max_mds_cookiesize = + body->max_cookiesize; } - EXIT; } -struct mdc_cache_waiter { - struct list_head mcw_entry; - wait_queue_head_t mcw_waitq; + +struct mdc_cache_waiter { + cfs_list_t mcw_entry; + cfs_waitq_t mcw_waitq; }; /* mdc/mdc_locks.c */ @@ -85,4 +176,7 @@ int it_open_error(int phase, struct lookup_intent *it); int mdc_sendpage(struct obd_export *exp, const struct lu_fid *fid, const struct page *page, int offset); #endif + +/** @} mdc */ + #endif