X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Finclude%2Flustre_dlm.h;h=161d55ffeb972b261ceee95d56e0a62712b8995d;hp=6c9464bc2dc89dc16a0626cd4d59e9d6cc40b496;hb=5c1e896af77115ec1d0637a269915109c79b08fc;hpb=6dbf1ffdec1240fbc8a86210b439d31a6c80c8de;ds=sidebyside diff --git a/lustre/include/lustre_dlm.h b/lustre/include/lustre_dlm.h index 6c9464b..161d55f 100644 --- a/lustre/include/lustre_dlm.h +++ b/lustre/include/lustre_dlm.h @@ -26,7 +26,7 @@ * GPL HEADER END */ /* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. */ /* @@ -37,6 +37,11 @@ #ifndef _LUSTRE_DLM_H__ #define _LUSTRE_DLM_H__ +/** \defgroup ldlm ldlm + * + * @{ + */ + #if defined(__linux__) #include #elif defined(__APPLE__) @@ -105,7 +110,7 @@ typedef enum { #define LDLM_FL_REPLAY 0x000100 #define LDLM_FL_INTENT_ONLY 0x000200 /* don't grant lock, just do intent */ -#define LDLM_FL_LOCAL_ONLY 0x000400 /* see ldlm_cli_cancel_unused */ +#define LDLM_FL_LOCAL_ONLY 0x000400 /* don't run the cancel callback under ldlm_cli_cancel_unused */ #define LDLM_FL_FAILED 0x000800 @@ -113,7 +118,7 @@ typedef enum { #define LDLM_FL_HAS_INTENT 0x001000 /* lock request has intent */ #define LDLM_FL_CANCELING 0x002000 /* lock cancel has already been sent */ #define LDLM_FL_LOCAL 0x004000 /* local lock (ie, no srv/cli split) */ -#define LDLM_FL_WARN 0x008000 /* see ldlm_cli_cancel_unused */ +/* was LDLM_FL_WARN until 2.0.0 0x008000 */ #define LDLM_FL_DISCARD_DATA 0x010000 /* discard (no writeback) on cancel */ #define LDLM_FL_NO_TIMEOUT 0x020000 /* Blocked by group lock - wait @@ -163,8 +168,7 @@ typedef enum { * w/o involving separate thread. in order to decrease cs rate */ #define LDLM_FL_ATOMIC_CB 0x4000000 -/* Cancel lock asynchronously. See ldlm_cli_cancel_unused_resource. */ -#define LDLM_FL_ASYNC 0x8000000 +/* was LDLM_FL_ASYNC until 2.0.0 0x8000000 */ /* It may happen that a client initiate 2 operations, e.g. unlink and mkdir, * such that server send blocking ast for conflict locks to this client for @@ -199,6 +203,10 @@ typedef enum { * emulation + race with upcoming bl_ast. */ #define LDLM_FL_FAIL_LOC 0x100000000ULL +/* Used while processing the unused list to know that we have already + * handled this lock and decided to skip it */ +#define LDLM_FL_SKIPPED 0x200000000ULL + /* The blocking callback is overloaded to perform two functions. These flags * indicate which operation should be performed. */ #define LDLM_CB_BLOCKING 1 @@ -278,9 +286,9 @@ struct ldlm_pool_ops { #define LDLM_POOLS_THREAD_PERIOD (1) /** - * 5% margin for modest pools. See ldlm_pool.c for details. + * ~6% margin for modest pools. See ldlm_pool.c for details. */ -#define LDLM_POOLS_MODEST_MARGIN (5) +#define LDLM_POOLS_MODEST_MARGIN_SHIFT (4) /** * Default recalc period for server side pools in sec. @@ -364,11 +372,14 @@ typedef int (*ldlm_res_policy)(struct ldlm_namespace *, struct ldlm_lock **, void *req_cookie, ldlm_mode_t mode, int flags, void *data); +typedef int (*ldlm_cancel_for_recovery)(struct ldlm_lock *lock); + struct ldlm_valblock_ops { int (*lvbo_init)(struct ldlm_resource *res); int (*lvbo_update)(struct ldlm_resource *res, struct ptlrpc_request *r, int increase); + int (*lvbo_free)(struct ldlm_resource *res); }; typedef enum { @@ -479,6 +490,9 @@ struct ldlm_namespace { struct obd_device *ns_obd; struct adaptive_timeout ns_at_estimate;/* estimated lock callback time*/ + + /* callback to cancel locks before replaying it during recovery */ + ldlm_cancel_for_recovery ns_cancel_for_recovery; }; static inline int ns_is_client(struct ldlm_namespace *ns) @@ -507,6 +521,13 @@ static inline int ns_connect_lru_resize(struct ldlm_namespace *ns) return !!(ns->ns_connect_flags & OBD_CONNECT_LRU_RESIZE); } +static inline void ns_register_cancel(struct ldlm_namespace *ns, + ldlm_cancel_for_recovery arg) +{ + LASSERT(ns != NULL); + ns->ns_cancel_for_recovery = arg; +} + /* * * Resource hash table @@ -546,6 +567,14 @@ struct ldlm_interval_tree { #define LUSTRE_TRACKS_LOCK_EXP_REFS (1) +/* Cancel flag. */ +typedef enum { + LCF_ASYNC = 0x1, /* Cancel locks asynchronously. */ + LCF_LOCAL = 0x2, /* Cancel locks locally, not notifing server */ + LCF_BL_AST = 0x4, /* Cancel locks marked as LDLM_FL_BL_AST + * in the same RPC */ +} ldlm_cancel_flags_t; + struct ldlm_lock { /** * Must be first in the structure. @@ -756,8 +785,34 @@ struct ldlm_resource { * List of references to this resource. For debugging. */ struct lu_ref lr_reference; + + struct inode *lr_lvb_inode; }; +static inline struct ldlm_namespace * +ldlm_res_to_ns(struct ldlm_resource *res) +{ + return res->lr_namespace; +} + +static inline struct ldlm_namespace * +ldlm_lock_to_ns(struct ldlm_lock *lock) +{ + return ldlm_res_to_ns(lock->l_resource); +} + +static inline char * +ldlm_lock_to_ns_name(struct ldlm_lock *lock) +{ + return ldlm_lock_to_ns(lock)->ns_name; +} + +static inline struct adaptive_timeout * +ldlm_lock_to_ns_at(struct ldlm_lock *lock) +{ + return &ldlm_lock_to_ns(lock)->ns_at_estimate; +} + struct ldlm_ast_work { struct ldlm_lock *w_lock; int w_blocking; @@ -852,7 +907,7 @@ int ldlm_namespace_foreach_res(struct ldlm_namespace *ns, ldlm_res_iterator_t iter, void *closure); int ldlm_replay_locks(struct obd_import *imp); -void ldlm_resource_iterate(struct ldlm_namespace *, const struct ldlm_res_id *, +int ldlm_resource_iterate(struct ldlm_namespace *, const struct ldlm_res_id *, ldlm_iterator_t iter, void *data); /* ldlm_flock.c */ @@ -912,10 +967,10 @@ ldlm_handle2lock_long(const struct lustre_handle *h, int flags) static inline int ldlm_res_lvbo_update(struct ldlm_resource *res, struct ptlrpc_request *r, int increase) { - if (res->lr_namespace->ns_lvbo && - res->lr_namespace->ns_lvbo->lvbo_update) { - return res->lr_namespace->ns_lvbo->lvbo_update(res, r, - increase); + if (ldlm_res_to_ns(res)->ns_lvbo && + ldlm_res_to_ns(res)->ns_lvbo->lvbo_update) { + return ldlm_res_to_ns(res)->ns_lvbo->lvbo_update(res, r, + increase); } return 0; } @@ -1094,20 +1149,24 @@ int ldlm_handle_convert0(struct ptlrpc_request *req, const struct ldlm_request *dlm_req); int ldlm_cli_cancel(struct lustre_handle *lockh); int ldlm_cli_cancel_unused(struct ldlm_namespace *, const struct ldlm_res_id *, - int flags, void *opaque); + ldlm_cancel_flags_t flags, void *opaque); int ldlm_cli_cancel_unused_resource(struct ldlm_namespace *ns, const struct ldlm_res_id *res_id, ldlm_policy_data_t *policy, - ldlm_mode_t mode, int flags, void *opaque); + ldlm_mode_t mode, + ldlm_cancel_flags_t flags, + void *opaque); int ldlm_cli_cancel_req(struct obd_export *exp, cfs_list_t *head, - int count, int flags); + int count, ldlm_cancel_flags_t flags); int ldlm_cancel_resource_local(struct ldlm_resource *res, cfs_list_t *cancels, ldlm_policy_data_t *policy, ldlm_mode_t mode, int lock_flags, - int cancel_flags, void *opaque); + ldlm_cancel_flags_t cancel_flags, void *opaque); +int ldlm_cli_cancel_list_local(cfs_list_t *cancels, int count, + ldlm_cancel_flags_t flags); int ldlm_cli_cancel_list(cfs_list_t *head, int count, - struct ptlrpc_request *req, int flags); + struct ptlrpc_request *req, ldlm_cancel_flags_t flags); /* mds/handler.c */ /* This has to be here because recursive inclusion sucks. */ @@ -1180,4 +1239,7 @@ void ldlm_pool_set_clv(struct ldlm_pool *pl, __u64 clv); void ldlm_pool_set_limit(struct ldlm_pool *pl, __u32 limit); void ldlm_pool_add(struct ldlm_pool *pl, struct ldlm_lock *lock); void ldlm_pool_del(struct ldlm_pool *pl, struct ldlm_lock *lock); + +/** @} ldlm */ + #endif