X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Finclude%2Flustre_dlm.h;h=06b5a7bf73f26aa33d3dea98f0584031e3d5e8bf;hb=857874862ddffa816593e8d1c1f65587ca226bb7;hp=48722d5bdee598b2c8ab92167aa100095c80fdf4;hpb=022b102258cd85314f4fa1fb8322638cc79f4634;p=fs%2Flustre-release.git diff --git a/lustre/include/lustre_dlm.h b/lustre/include/lustre_dlm.h index 48722d5..06b5a7b 100644 --- a/lustre/include/lustre_dlm.h +++ b/lustre/include/lustre_dlm.h @@ -30,6 +30,7 @@ struct obd_device; #define LDLM_DEFAULT_LRU_SIZE (100 * num_online_cpus()) #define LDLM_DEFAULT_MAX_ALIVE (cfs_time_seconds(36000)) +#define LDLM_CTIME_AGE_LIMIT (10) typedef enum { ELDLM_OK = 0, @@ -131,6 +132,9 @@ 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 + /* 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 * the 1st operation, whereas the 2nd operation has canceled this lock and @@ -144,20 +148,14 @@ typedef enum { #define LDLM_FL_BL_AST 0x10000000 #define LDLM_FL_BL_DONE 0x20000000 -/* Cancel lock asynchronously. See ldlm_cli_cancel_unused_resource. */ -#define LDLM_FL_ASYNC 0x40000000 +/* measure lock contention and return -EUSERS if locking contention is high */ +#define LDLM_FL_DENY_ON_CONTENTION 0x40000000 /* The blocking callback is overloaded to perform two functions. These flags * indicate which operation should be performed. */ #define LDLM_CB_BLOCKING 1 #define LDLM_CB_CANCELING 2 -/* position flag of skip list pointers */ -#define LDLM_SL_HEAD(skip_list) ((skip_list)->next != NULL) -#define LDLM_SL_TAIL(skip_list) ((skip_list)->prev != NULL) -#define LDLM_SL_EMPTY(skip_list) ((skip_list)->next == NULL && \ - (skip_list)->prev == NULL) - /* compatibility matrix */ #define LCK_COMPAT_EX LCK_NL #define LCK_COMPAT_PW (LCK_COMPAT_EX | LCK_CR) @@ -174,9 +172,9 @@ static inline void lockmode_verify(ldlm_mode_t mode) LASSERT(mode > LCK_MINMODE && mode < LCK_MAXMODE); } -static inline int lockmode_compat(ldlm_mode_t exist, ldlm_mode_t new) +static inline int lockmode_compat(ldlm_mode_t exist_mode, ldlm_mode_t new_mode) { - return (lck_compat_array[exist] & new); + return (lck_compat_array[exist_mode] & new_mode); } /* @@ -235,34 +233,71 @@ struct ldlm_pool_ops { #define LDLM_POOLS_FAST_SLV_CHANGE (50) struct ldlm_pool { - /* Common pool fields */ - cfs_proc_dir_entry_t *pl_proc_dir; /* Pool proc directory. */ - char pl_name[100]; /* Pool name, should be long - * enough to contain complex - * proc entry name. */ - spinlock_t pl_lock; /* Lock for protecting slv/clv - * updates. */ - atomic_t pl_limit; /* Number of allowed locks in - * in pool, both, client and - * server side. */ - atomic_t pl_granted; /* Number of granted locks. */ - atomic_t pl_grant_rate; /* Grant rate per T. */ - atomic_t pl_cancel_rate; /* Cancel rate per T. */ - atomic_t pl_grant_speed; /* Grant speed (GR-CR) per T. */ - __u64 pl_server_lock_volume; /* Server lock volume. - * Protected by pl_lock */ - atomic_t pl_lock_volume_factor; /* Lock volume factor. */ - - time_t pl_recalc_time; /* Time when last slv from - * server was obtained. */ - struct ldlm_pool_ops *pl_ops; /* Recalc and shrink ops. */ - - int pl_grant_plan; /* Planned number of granted - * locks for next T. */ - int pl_grant_step; /* Grant plan step for next - * T. */ - - struct lprocfs_stats *pl_stats; /* Pool statistics. */ + /** + * Pool proc directory. + */ + cfs_proc_dir_entry_t *pl_proc_dir; + /** + * Pool name, should be long enough to contain compound proc entry name. + */ + char pl_name[100]; + /** + * Lock for protecting slv/clv updates. + */ + spinlock_t pl_lock; + /** + * Number of allowed locks in in pool, both, client and server side. + */ + atomic_t pl_limit; + /** + * Number of granted locks in + */ + atomic_t pl_granted; + /** + * Grant rate per T. + */ + atomic_t pl_grant_rate; + /** + * Cancel rate per T. + */ + atomic_t pl_cancel_rate; + /** + * Grant speed (GR-CR) per T. + */ + atomic_t pl_grant_speed; + /** + * Server lock volume. Protected by pl_lock. + */ + __u64 pl_server_lock_volume; + /** + * Current biggest client lock volume. Protected by pl_lock. + */ + __u64 pl_client_lock_volume; + /** + * Lock volume factor. SLV on client is calculated as following: + * server_slv * lock_volume_factor. + */ + atomic_t pl_lock_volume_factor; + /** + * Time when last slv from server was obtained. + */ + time_t pl_recalc_time; + /** + * Recalc and shrink ops. + */ + struct ldlm_pool_ops *pl_ops; + /** + * Planned number of granted locks for next T. + */ + int pl_grant_plan; + /** + * Grant plan step for next T. + */ + int pl_grant_step; + /** + * Pool statistics. + */ + struct lprocfs_stats *pl_stats; }; typedef int (*ldlm_res_policy)(struct ldlm_namespace *, struct ldlm_lock **, @@ -280,36 +315,89 @@ typedef enum { LDLM_NAMESPACE_MODEST = 1 << 1 } ldlm_appetite_t; -/* Default value for ->ns_shrink_thumb. If lock is not extent one its cost +/* + * Default value for ->ns_shrink_thumb. If lock is not extent one its cost * is one page. Here we have 256 pages which is 1M on i386. Thus by default * all extent locks which have more than 1M long extent will be kept in lru, - * others (including ibits locks) will be canceled on memory pressure event. */ + * others (including ibits locks) will be canceled on memory pressure event. + */ #define LDLM_LOCK_SHRINK_THUMB 256 +/* + * Default values for the "max_nolock_size", "contention_time" and + * "contended_locks" namespace tunables. + */ +#define NS_DEFAULT_MAX_NOLOCK_BYTES 0 +#define NS_DEFAULT_CONTENTION_SECONDS 2 +#define NS_DEFAULT_CONTENDED_LOCKS 32 + struct ldlm_namespace { + /** + * Namespace name. Used for logging, etc. + */ char *ns_name; - ldlm_side_t ns_client; /* is this a client-side lock tree? */ - __u64 ns_connect_flags; /* ns connect flags supported - * by server (may be changed via proc, - * lru resize may be disabled/enabled) */ - __u64 ns_orig_connect_flags; /* client side orig connect - * flags supported by server */ - struct list_head *ns_hash; /* hash table for ns */ + + /** + * Is this a client-side lock tree? + */ + ldlm_side_t ns_client; + + /** + * Namespce connect flags supported by server (may be changed via proc, + * lru resize may be disabled/enabled). + */ + __u64 ns_connect_flags; + + /** + * Client side orig connect flags supported by server. + */ + __u64 ns_orig_connect_flags; + + /** + * Hash table for namespace. + */ + struct list_head *ns_hash; spinlock_t ns_hash_lock; - __u32 ns_refcount; /* count of resources in the hash */ - struct list_head ns_root_list; /* all root resources in ns */ - struct list_head ns_list_chain; /* position in global NS list */ - struct list_head ns_unused_list; /* all root resources in ns */ + /** + * Count of resources in the hash. + */ + __u32 ns_refcount; + + /** + * All root resources in namespace. + */ + struct list_head ns_root_list; + + /** + * Position in global namespace list. + */ + struct list_head ns_list_chain; + + /** + * All root resources in namespace. + */ + struct list_head ns_unused_list; int ns_nr_unused; spinlock_t ns_unused_lock; unsigned int ns_max_unused; unsigned int ns_max_age; + + /** + * Seconds. + */ + unsigned int ns_ctime_age_limit; - /* Lower limit to number of pages in lock to keep it in cache */ + /** + * Lower limit to number of pages in lock to keep it in cache. + */ unsigned int ns_shrink_thumb; - cfs_time_t ns_next_dump; /* next debug dump, jiffies */ + + /** + * Next debug dump, jiffies. + */ + cfs_time_t ns_next_dump; atomic_t ns_locks; __u64 ns_resources; @@ -319,6 +407,30 @@ struct ldlm_namespace { cfs_waitq_t ns_waitq; struct ldlm_pool ns_pool; ldlm_appetite_t ns_appetite; + + /** + * If more than @ns_contented_locks found, the resource considered + * as contended. + */ + unsigned ns_contended_locks; + + /** + * The resource remembers contended state during @ns_contention_time, + * in seconds. + */ + unsigned ns_contention_time; + + /** + * Limit size of nolock requests, in bytes. + */ + unsigned ns_max_nolock_size; + + /** + * Backward link to obd, required for ldlm pool to store new SLV. + */ + struct obd_device *ns_obd; + + struct adaptive_timeout ns_at_estimate;/* estimated lock callback time*/ }; static inline int ns_is_client(struct ldlm_namespace *ns) @@ -397,11 +509,8 @@ struct ldlm_lock { /* protected by ns_hash_lock. FIXME */ struct list_head l_lru; - /* protected by lr_lock */ - struct list_head l_res_link; // position in one of three res lists - - struct list_head l_sl_mode; // skip pointer for request mode - struct list_head l_sl_policy; // skip pointer for inodebits + /* protected by lr_lock, linkage to resource's lock queues */ + struct list_head l_res_link; struct ldlm_interval *l_tree_node; /* tree node for ldlm_extent */ @@ -442,6 +551,10 @@ struct ldlm_lock { void *l_lvb_data; /* an LVB received during */ void *l_lvb_swabber; /* an enqueue */ void *l_ast_data; + spinlock_t l_extents_list_lock; + struct list_head l_extents_list; + + struct list_head l_cache_locks_list; /* Server-side-only members */ @@ -456,6 +569,10 @@ struct ldlm_lock { struct list_head l_cp_ast; struct ldlm_lock *l_blocking_lock; int l_bl_ast_run; + + /* protected by lr_lock, linkages to "skip lists" */ + struct list_head l_sl_mode; + struct list_head l_sl_policy; }; struct ldlm_resource { @@ -484,6 +601,9 @@ struct ldlm_resource { struct semaphore lr_lvb_sem; __u32 lr_lvb_len; void *lr_lvb_data; + + /* when the resource was considered as contended */ + cfs_time_t lr_contention_time; }; struct ldlm_ast_work { @@ -500,9 +620,9 @@ struct ldlm_ast_work { struct ldlm_enqueue_info { __u32 ei_type; /* Type of the lock being enqueued. */ __u32 ei_mode; /* Mode of the lock being enqueued. */ - void *ei_cb_bl; /* Different callbacks for lock handling (blocking, */ - void *ei_cb_cp; /* completion, glimpse) */ - void *ei_cb_gl; + void *ei_cb_bl; /* blocking lock callback */ + void *ei_cb_cp; /* lock completion callback */ + void *ei_cb_gl; /* lock glimpse callback */ void *ei_cbdata; /* Data to be passed into callbacks. */ }; @@ -598,7 +718,7 @@ int ldlm_del_waiting_lock(struct ldlm_lock *lock); int ldlm_refresh_waiting_lock(struct ldlm_lock *lock); void ldlm_revoke_export_locks(struct obd_export *exp); int ldlm_get_ref(void); -void ldlm_put_ref(int force); +void ldlm_put_ref(void); /* ldlm_lock.c */ ldlm_processing_policy ldlm_get_processing_policy(struct ldlm_resource *res); @@ -663,6 +783,8 @@ void ldlm_lock_addref(struct lustre_handle *lockh, __u32 mode); void ldlm_lock_decref(struct lustre_handle *lockh, __u32 mode); void ldlm_lock_decref_and_cancel(struct lustre_handle *lockh, __u32 mode); void ldlm_lock_allow_match(struct ldlm_lock *lock); +int ldlm_lock_fast_match(struct ldlm_lock *, int, obd_off, obd_off, void **); +void ldlm_lock_fast_release(void *, int); ldlm_mode_t ldlm_lock_match(struct ldlm_namespace *ns, int flags, const struct ldlm_res_id *, ldlm_type_t type, ldlm_policy_data_t *, ldlm_mode_t mode, @@ -678,16 +800,20 @@ void ldlm_lock_dump_handle(int level, struct lustre_handle *); void ldlm_unlink_lock_skiplist(struct ldlm_lock *req); /* resource.c */ -struct ldlm_namespace *ldlm_namespace_new(char *name, ldlm_side_t client, - ldlm_appetite_t apt); +struct ldlm_namespace * +ldlm_namespace_new(struct obd_device *obd, char *name, + ldlm_side_t client, ldlm_appetite_t apt); int ldlm_namespace_cleanup(struct ldlm_namespace *ns, int flags); -int ldlm_namespace_free(struct ldlm_namespace *ns, int force); -void ldlm_namespace_move(struct ldlm_namespace *ns, ldlm_side_t client); -struct ldlm_namespace *ldlm_namespace_first(ldlm_side_t client); +void ldlm_namespace_free(struct ldlm_namespace *ns, + struct obd_import *imp, int force); +void ldlm_namespace_register(struct ldlm_namespace *ns, ldlm_side_t client); +void ldlm_namespace_unregister(struct ldlm_namespace *ns, ldlm_side_t client); +void ldlm_namespace_move_locked(struct ldlm_namespace *ns, ldlm_side_t client); +struct ldlm_namespace *ldlm_namespace_first_locked(ldlm_side_t client); +void ldlm_namespace_get_locked(struct ldlm_namespace *ns); +void ldlm_namespace_put_locked(struct ldlm_namespace *ns, int wakeup); void ldlm_namespace_get(struct ldlm_namespace *ns); void ldlm_namespace_put(struct ldlm_namespace *ns, int wakeup); -void ldlm_namespace_get_nolock(struct ldlm_namespace *ns); -void ldlm_namespace_put_nolock(struct ldlm_namespace *ns, int wakeup); int ldlm_proc_setup(void); #ifdef LPROCFS void ldlm_proc_cleanup(void); @@ -827,9 +953,12 @@ int ldlm_pool_shrink(struct ldlm_pool *pl, int nr, void ldlm_pool_fini(struct ldlm_pool *pl); int ldlm_pool_setup(struct ldlm_pool *pl, int limit); int ldlm_pool_recalc(struct ldlm_pool *pl); +__u32 ldlm_pool_get_lvf(struct ldlm_pool *pl); __u64 ldlm_pool_get_slv(struct ldlm_pool *pl); +__u64 ldlm_pool_get_clv(struct ldlm_pool *pl); __u32 ldlm_pool_get_limit(struct ldlm_pool *pl); void ldlm_pool_set_slv(struct ldlm_pool *pl, __u64 slv); +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);